@travetto/model 6.0.1 → 7.0.0-rc.0

package/README.md

@@ -16,7 +16,7 @@ yarn add @travetto/model
 This module provides a set of contracts/interfaces to data model persistence, modification and retrieval.  This module builds heavily upon the [Schema](https://github.com/travetto/travetto/tree/main/module/schema#readme "Data type registry for runtime validation, reflection and binding."), which is used for data model validation.
 
 ## 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#L13) 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 [ModelRegistry](https://github.com/travetto/travetto/tree/main/module/model/src/registry/model.ts#L14).
+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).
 
 **Code: Basic Structure**
 ```typescript
@@ -241,7 +241,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#L13) 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
@@ -277,7 +277,7 @@ To enforce that these contracts are honored, the module provides shared test sui
 
 **Code: Memory Service Test Configuration**
 ```typescript
-import { DependencyRegistry } from '@travetto/di';
+import { DependencyRegistryIndex } from '@travetto/di';
 import { AppError, castTo, Class, classConstruct } from '@travetto/runtime';
 
 import { ModelBulkUtil } from '../../src/util/bulk.ts';
@@ -328,7 +328,7 @@ export abstract class BaseModelSuite<T> {
   }
 
   get service(): Promise<T> {
-    return DependencyRegistry.getInstance(this.serviceClass);
+    return DependencyRegistryIndex.getInstance(this.serviceClass);
   }
 
   async toArray<U>(src: AsyncIterable<U> | AsyncGenerator<U>): Promise<U[]> {
@@ -342,7 +342,7 @@ export abstract class BaseModelSuite<T> {
 ```
 
 ## 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#L13)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**
 ```bash
@@ -365,7 +365,7 @@ Models
 ```
 
 ## 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#L13)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**
 ```bash

package/__index__.ts

@@ -1,5 +1,6 @@
 export * from './src/registry/decorator.ts';
-export * from './src/registry/model.ts';
+export * from './src/registry/registry-index.ts';
+export * from './src/registry/registry-adapter.ts';
 export * from './src/registry/types.ts';
 export * from './src/types/model.ts';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model",
-  "version": "6.0.1",
+  "version": "7.0.0-rc.0",
   "description": "Datastore abstraction for core operations.",
   "keywords": [
     "datastore",
@@ -26,14 +26,14 @@
     "directory": "module/model"
   },
   "dependencies": {
-    "@travetto/config": "^6.0.1",
-    "@travetto/di": "^6.0.1",
-    "@travetto/registry": "^6.0.1",
-    "@travetto/schema": "^6.0.1"
+    "@travetto/config": "^7.0.0-rc.0",
+    "@travetto/di": "^7.0.0-rc.0",
+    "@travetto/registry": "^7.0.0-rc.0",
+    "@travetto/schema": "^7.0.0-rc.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^6.0.1",
-    "@travetto/test": "^6.0.2"
+    "@travetto/cli": "^7.0.0-rc.0",
+    "@travetto/test": "^7.0.0-rc.0"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/registry/decorator.ts

@@ -1,54 +1,61 @@
-import { AppError, asConstructable, castTo, Class } from '@travetto/runtime';
-import { SchemaRegistry } from '@travetto/schema';
+import { AppError, castTo, Class, getClass } from '@travetto/runtime';
+import { SchemaRegistryIndex } from '@travetto/schema';
 
 import { ModelType } from '../types/model.ts';
-import { ModelRegistry } from './model.ts';
-import { DataHandler, IndexConfig, ModelOptions, PrePersistScope } from './types.ts';
+import { DataHandler, IndexConfig, ModelConfig, PrePersistScope } from './types.ts';
+import { ModelRegistryIndex } from './registry-index.ts';
 
 /**
  * Model decorator, extends `@Schema`
  *
  * @augments `@travetto/schema:Schema`
+ * @kind decorator
  */
-export function Model(conf: Partial<ModelOptions<ModelType>> | string = {}) {
-  return function <T extends ModelType, U extends Class<T>>(target: U): U {
+export function Model(conf: Partial<ModelConfig<ModelType>> | string = {}) {
+  return function <T extends ModelType, U extends Class<T>>(cls: U): U {
     if (typeof conf === 'string') {
       conf = { store: conf };
     }
-    ModelRegistry.register(target, conf);
-    SchemaRegistry.register(target, { baseType: conf.baseType });
-    return target;
+    ModelRegistryIndex.getForRegister(cls).register(conf);
+    if (SchemaRegistryIndex.getForRegister(cls).get().fields.id) {
+      SchemaRegistryIndex.getForRegister(cls).registerField('id', { required: { active: false } });
+    }
+    return cls;
   };
 }
 
 /**
  * Defines an index on a model
+ * @kind decorator
  */
 export function Index<T extends ModelType>(...indices: IndexConfig<T>[]) {
   if (indices.some(x => x.fields.some(f => f === 'id'))) {
     throw new AppError('Cannot create an index with the id field');
   }
-  return function (target: Class<T>): void {
-    ModelRegistry.getOrCreatePending(target).indices!.push(...indices);
+  return function (cls: Class<T>): void {
+    ModelRegistryIndex.getForRegister(cls).register({ indices });
   };
 }
 
 /**
  * Model field decorator for denoting expiry date/time
  * @augments `@travetto/schema:Field`
+ * @kind decorator
  */
 export function ExpiresAt() {
-  return <K extends string, T extends Partial<Record<K, Date>>>(tgt: T, prop: K): void => {
-    ModelRegistry.register(asConstructable(tgt).constructor, { expiresAt: prop });
+  return <K extends string, T extends Partial<Record<K, Date>>>(instance: T, property: K): void => {
+    ModelRegistryIndex.getForRegister(getClass(instance)).register({ expiresAt: property });
   };
 }
 
 /**
  * Model class decorator for pre-persist behavior
+ * @augments `@travetto/schema:Schema`
+ * @kind decorator
  */
 export function PrePersist<T>(handler: DataHandler<T>, scope: PrePersistScope = 'all') {
-  return function (tgt: Class<T>): void {
-    ModelRegistry.registerDataHandlers(tgt, {
+  return function (cls: Class<T>): void {
+    ModelRegistryIndex.getForRegister(cls).register({
       prePersist: [{
         scope,
         handler: castTo(handler)
@@ -59,15 +66,17 @@ export function PrePersist<T>(handler: DataHandler<T>, scope: PrePersistScope =
 
 /**
  * Model field decorator for pre-persist value setting
+ * @augments `@travetto/schema:Field`
+ * @kind decorator
  */
 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 {
-    ModelRegistry.registerDataHandlers(asConstructable(tgt).constructor, {
+  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[prop] = handler(cInst[prop]);
+          cInst[property] = handler(cInst[property]);
         }
       }]
     });
@@ -76,15 +85,17 @@ export function PersistValue<T>(handler: (curr: T | undefined) => T, scope: PreP
 
 /**
  * Prevent a field from being persisted
+ * @augments `@travetto/schema:Field`
+ * @kind decorator
  */
 export function Transient<T>() {
-  return function <K extends string, C extends Partial<Record<K, T>>>(tgt: C, prop: K): void {
-    ModelRegistry.registerDataHandlers(asConstructable(tgt).constructor, {
+  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[prop];
+          delete cInst[property];
         }
       }]
     });
@@ -93,9 +104,11 @@ export function Transient<T>() {
 
 /**
  * Model class decorator for post-load behavior
+ * @augments `@travetto/schema:Schema`
+ * @kind decorator
  */
 export function PostLoad<T>(handler: DataHandler<T>) {
-  return function (tgt: Class<T>): void {
-    ModelRegistry.registerDataHandlers(tgt, { postLoad: [castTo(handler)] });
+  return function (cls: Class<T>): void {
+    ModelRegistryIndex.getForRegister(cls).register({ postLoad: [castTo(handler)] });
   };
 }

package/src/registry/registry-adapter.ts

@@ -0,0 +1,56 @@
+import type { RegistryAdapter } from '@travetto/registry';
+import { Class } from '@travetto/runtime';
+import { SchemaRegistryIndex } from '@travetto/schema';
+
+import { ModelConfig } from './types';
+
+function combineClasses(target: ModelConfig, sources: Partial<ModelConfig>[]): ModelConfig {
+  for (const source of sources) {
+    Object.assign(target, source, {
+      indices: [...(target.indices || []), ...(source.indices || [])],
+      postLoad: [...(target.postLoad || []), ...(source.postLoad || [])],
+      prePersist: [...(target.prePersist || []), ...(source.prePersist || [])],
+    });
+  }
+  return target;
+}
+
+export class ModelRegistryAdapter implements RegistryAdapter<ModelConfig> {
+  #cls: Class;
+  #config: ModelConfig;
+
+  constructor(cls: Class) {
+    this.#cls = cls;
+  }
+
+  register(...data: Partial<ModelConfig>[]): ModelConfig {
+    const cfg = this.#config ??= {
+      class: this.#cls,
+      indices: [],
+      autoCreate: true,
+      store: this.#cls.name.toLowerCase(),
+      postLoad: [],
+      prePersist: []
+    };
+    combineClasses(cfg, data);
+    return cfg;
+  }
+
+  finalize(parent?: ModelConfig): void {
+    const config = this.#config;
+    if (parent) {
+      const parentSchema = parent ? SchemaRegistryIndex.getConfig(parent.class) : undefined; // Ensure schema is finalized first
+
+      if (parentSchema?.discriminatedField && parent.store) {
+        config.store = parent.store;
+      }
+
+      config.postLoad = [...parent.postLoad ?? [], ...config.postLoad ?? []];
+      config.prePersist = [...parent.prePersist ?? [], ...config.prePersist ?? []];
+    }
+  }
+
+  get(): ModelConfig {
+    return this.#config;
+  }
+}

package/src/registry/registry-index.ts

@@ -0,0 +1,143 @@
+import { ChangeEvent, RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
+import { AppError, castTo, Class } from '@travetto/runtime';
+import { SchemaRegistryIndex } from '@travetto/schema';
+
+import { IndexConfig, IndexType, ModelConfig } from './types';
+import { ModelType } from '../types/model';
+import { ModelRegistryAdapter } from './registry-adapter';
+import { IndexNotSupported } from '../error/invalid-index';
+import { NotFoundError } from '../error/not-found';
+
+type IndexResult<T extends ModelType, K extends IndexType[]> = IndexConfig<T> & { type: K[number] };
+
+/**
+ * Model registry index for managing model configurations across classes
+ */
+export class ModelRegistryIndex implements RegistryIndex {
+
+  static #instance = Registry.registerIndex(this);
+
+  static getForRegister(cls: Class): ModelRegistryAdapter {
+    return this.#instance.store.getForRegister(cls);
+  }
+
+  static getConfig(cls: Class): ModelConfig {
+    return this.#instance.getConfig(cls);
+  }
+
+  static has(cls: Class): boolean {
+    return this.#instance.store.has(cls);
+  }
+
+  static getStoreName<T extends ModelType>(cls: Class<T>): string {
+    return this.#instance.getStoreName(cls);
+  }
+
+  static getIndices<T extends ModelType, K extends IndexType[]>(cls: Class<T>, supportedTypes?: K): IndexResult<T, K>[] {
+    return this.#instance.getIndices(cls, supportedTypes);
+  }
+
+  static getIndex<T extends ModelType, K extends IndexType[]>(cls: Class<T>, name: string, supportedTypes?: K): IndexResult<T, K> {
+    return this.#instance.getIndex(cls, name, supportedTypes);
+  }
+
+  static getExpiryFieldName<T extends ModelType>(cls: Class<T>): keyof T {
+    return this.#instance.getExpiryFieldName(cls);
+  }
+
+  static getClasses(): Class[] {
+    return this.#instance.store.getClasses();
+  }
+
+  /**
+   * Default mapping of classes by class name or
+   * by requested store name.  This is the state at the
+   * start of the application.
+   */
+  #modelNameMapping = new Map<string, Set<string>>();
+
+  store = new RegistryIndexStore(ModelRegistryAdapter);
+
+  #addClass(cls: Class): void {
+    const schema = SchemaRegistryIndex.getConfig(cls);
+
+    // Don't index on discriminated schemas
+    if (schema.discriminatedType && !schema.discriminatedBase) {
+      return;
+    }
+
+    const { store } = this.getConfig(cls);
+    let classes = this.#modelNameMapping.get(store);
+    if (!classes) {
+      this.#modelNameMapping.set(store, classes = new Set());
+    }
+    classes.add(cls.Ⲑid);
+
+    // 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', {
+        details: { classes: [...classes].toSorted() }
+      });
+    }
+  }
+
+  #removeClass(cls: Class): void {
+    const { store } = this.store.get(cls).get();
+    this.#modelNameMapping.get(store)?.delete(cls.Ⲑid);
+  }
+
+  process(events: ChangeEvent<Class>[]): void {
+    for (const event of events) {
+      if ('prev' in event) {
+        this.#removeClass(event.prev);
+      }
+      if ('curr' in event) {
+        this.#addClass(event.curr);
+      }
+    }
+  }
+
+  getConfig(cls: Class): ModelConfig<ModelType> {
+    return this.store.get(cls).get();
+  }
+
+  /**
+   * Get the apparent store for a type, handling polymorphism when appropriate
+   */
+  getStoreName(cls: Class): string {
+    return this.store.get(cls).get().store;
+  }
+
+  /**
+   * Get Index
+   */
+  getIndex<T extends ModelType, K extends IndexType[]>(cls: Class<T>, name: string, supportedTypes?: K): IndexResult<T, K> {
+    const cfg = this.getConfig(cls).indices?.find((x): x is IndexConfig<T> => x.name === name);
+    if (!cfg) {
+      throw new NotFoundError(`${cls.name} Index`, `${name}`);
+    }
+    if (supportedTypes && !supportedTypes.includes(cfg.type)) {
+      throw new IndexNotSupported(cls, cfg, `${cfg.type} indices are not supported.`);
+    }
+    return cfg;
+  }
+
+  /**
+   * Get Indices
+   */
+  getIndices<T extends ModelType, K extends IndexType[]>(cls: Class<T>, supportedTypes?: K): IndexResult<T, K>[] {
+    return (this.getConfig(cls).indices ?? []).filter((x): x is IndexConfig<T> => !supportedTypes || supportedTypes.includes(x.type));
+  }
+
+  /**
+   * Get expiry field
+   * @param cls
+   */
+  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`);
+    }
+    return castTo(expiry);
+  }
+}

package/src/registry/types.ts

@@ -1,24 +1,15 @@
-import type { Class, Primitive } from '@travetto/runtime';
+import type { Class, RetainPrimitiveFields } from '@travetto/runtime';
 
 import { ModelType } from '../types/model.ts';
 
-type ValidFieldNames<T> = {
-  [K in keyof T]:
-  (T[K] extends (Primitive | undefined) ? K :
-    (T[K] extends (Function | undefined) ? never :
-      K))
-}[keyof T];
-
-type RetainFields<T> = Pick<T, ValidFieldNames<T>>;
-
 export type SortClauseRaw<T> = {
   [P in keyof T]?:
-  T[P] extends object ? SortClauseRaw<RetainFields<T[P]>> : 1 | -1;
+  T[P] extends object ? SortClauseRaw<RetainPrimitiveFields<T[P]>> : 1 | -1;
 };
 
 type IndexClauseRaw<T> = {
   [P in keyof T]?:
-  T[P] extends object ? IndexClauseRaw<RetainFields<T[P]>> : 1 | -1 | true;
+  T[P] extends object ? IndexClauseRaw<RetainPrimitiveFields<T[P]>> : 1 | -1 | true;
 };
 
 export type DataHandler<T = unknown> = (inst: T) => (Promise<T | void> | T | void);
@@ -26,9 +17,9 @@ export type DataHandler<T = unknown> = (inst: T) => (Promise<T | void> | T | voi
 export type PrePersistScope = 'full' | 'partial' | 'all';
 
 /**
- * Model options
+ * Model config
  */
-export class ModelOptions<T extends ModelType = ModelType> {
+export class ModelConfig<T extends ModelType = ModelType> {
   /**
    * Class for model
    */
@@ -36,15 +27,7 @@ export class ModelOptions<T extends ModelType = ModelType> {
   /**
    * Store name
    */
-  store?: string;
-  /**
-   * If a sub type
-   */
-  subType?: boolean;
-  /**
-   * Is a base type?
-   */
-  baseType?: boolean;
+  store: string;
   /**
    * Indices
    */
@@ -54,13 +37,13 @@ export class ModelOptions<T extends ModelType = ModelType> {
    */
   extra?: object;
   /**
-   * Does the model support expiry
+   * Expiry field
    */
-  expiresAt: string;
+  expiresAt?: string;
   /**
    * Auto create in development mode
    */
-  autoCreate: boolean;
+  autoCreate?: boolean;
   /**
    * Pre-persist handlers
    */
@@ -87,11 +70,11 @@ export type IndexConfig<T extends ModelType> = {
   /**
    * Fields and sort order
    */
-  fields: IndexClauseRaw<RetainFields<T>>[];
+  fields: IndexClauseRaw<RetainPrimitiveFields<T>>[];
   /**
    * Type
    */
   type: IndexType;
 };
 
-export type IndexField<T extends ModelType> = IndexClauseRaw<RetainFields<T>>;
+export type IndexField<T extends ModelType> = IndexClauseRaw<RetainPrimitiveFields<T>>;

package/src/util/crud.ts

@@ -1,7 +1,7 @@
-import { castTo, Class, Util, asConstructable, AppError, hasFunction } from '@travetto/runtime';
-import { DataUtil, SchemaRegistry, SchemaValidator, ValidationError, ValidationResultError } from '@travetto/schema';
+import { castTo, Class, Util, AppError, hasFunction } from '@travetto/runtime';
+import { DataUtil, SchemaRegistryIndex, SchemaValidator, ValidationError, ValidationResultError } from '@travetto/schema';
 
-import { ModelRegistry } from '../registry/model.ts';
+import { ModelRegistryIndex } from '../registry/registry-index.ts';
 import { ModelIdSource, ModelType, OptionalId } from '../types/model.ts';
 import { NotFoundError } from '../error/not-found.ts';
 import { ExistsError } from '../error/exists.ts';
@@ -47,7 +47,7 @@ export class ModelCrudUtil {
       resolvedInput = input;
     }
 
-    const result = ModelRegistry.getBaseModel(cls).from(resolvedInput);
+    const result = SchemaRegistryIndex.getBaseClass(cls).from(resolvedInput);
 
     if (!(result instanceof cls || result.constructor.Ⲑid === cls.Ⲑid)) {
       if (onTypeMismatch === 'notfound') {
@@ -75,10 +75,7 @@ export class ModelCrudUtil {
       item = cls.from(castTo(item));
     }
 
-    const config = ModelRegistry.get(asConstructable(item).constructor);
-    if (config.subType) { // Sub-typing, assign type
-      SchemaRegistry.ensureInstanceTypeField(cls, item);
-    }
+    SchemaRegistryIndex.get(cls).ensureInstanceTypeField(item);
 
     item = await this.prePersist(cls, item, scope);
 
@@ -105,7 +102,8 @@ export class ModelCrudUtil {
    * Ensure subtype is not supported
    */
   static ensureNotSubType(cls: Class): void {
-    if (ModelRegistry.get(cls).subType) {
+    const config = SchemaRegistryIndex.getConfig(cls);
+    if (config.discriminatedType && !config.discriminatedBase) {
       throw new SubTypeNotSupportedError(cls);
     }
   }
@@ -114,7 +112,7 @@ export class ModelCrudUtil {
    * Pre persist behavior
    */
   static async prePersist<T>(cls: Class<T>, item: T, scope: PrePersistScope): Promise<T> {
-    const config = ModelRegistry.get(cls);
+    const config = ModelRegistryIndex.getConfig(cls);
     for (const state of (config.prePersist ?? [])) {
       if (state.scope === scope || scope === 'all' || state.scope === 'all') {
         const handler: DataHandler<T> = castTo(state.handler);
@@ -131,7 +129,7 @@ export class ModelCrudUtil {
    * Post load behavior
    */
   static async postLoad<T>(cls: Class<T>, item: T): Promise<T> {
-    const config = ModelRegistry.get(cls);
+    const config = ModelRegistryIndex.getConfig(cls);
     for (const handler of castTo<DataHandler<T>[]>(config.postLoad ?? [])) {
       item = await handler(item) ?? item;
     }

package/src/util/expiry.ts

@@ -1,8 +1,8 @@
 import { ShutdownManager, Class, TimeSpan, TimeUtil, Util, castTo, hasFunction } from '@travetto/runtime';
 
-import { ModelRegistry } from '../registry/model.ts';
 import { ModelExpirySupport } from '../types/expiry.ts';
 import { ModelType } from '../types/model.ts';
+import { ModelRegistryIndex } from '../registry/registry-index.ts';
 
 /**
  * Utils for model expiry
@@ -18,7 +18,7 @@ export class ModelExpiryUtil {
    * Get expiry info for a given item
    */
   static getExpiryState<T extends ModelType>(cls: Class<T>, item: T): { expiresAt?: Date, expired?: boolean } {
-    const expKey = ModelRegistry.getExpiry(cls);
+    const expKey = ModelRegistryIndex.getExpiryFieldName(cls);
     const expiresAt: Date = castTo(item[expKey]);
 
     return {
@@ -32,7 +32,7 @@ export class ModelExpiryUtil {
    * @param svc
    */
   static registerCull(svc: ModelExpirySupport & { readonly config?: { cullRate?: number | TimeSpan } }): void {
-    const cullable = ModelRegistry.getClasses().filter(cls => !!ModelRegistry.get(cls).expiresAt);
+    const cullable = ModelRegistryIndex.getClasses().filter(cls => !!ModelRegistryIndex.getConfig(cls).expiresAt);
     if (svc.deleteExpired && cullable.length) {
       const running = new AbortController();
       const cullInterval = TimeUtil.asMillis(svc.config?.cullRate ?? '10m');

package/src/util/indexed.ts

@@ -2,11 +2,11 @@ import { castTo, Class, DeepPartial, hasFunction, TypedObject } from '@travetto/
 
 import { IndexNotSupported } from '../error/invalid-index.ts';
 import { NotFoundError } from '../error/not-found.ts';
-import { ModelRegistry } from '../registry/model.ts';
 import type { IndexConfig } from '../registry/types.ts';
 import type { ModelCrudSupport } from '../types/crud.ts';
 import type { ModelIndexedSupport } from '../types/indexed.ts';
 import type { ModelType, OptionalId } from '../types/model.ts';
+import { ModelRegistryIndex } from '../registry/registry-index.ts';
 
 type ComputeConfig = {
   includeSortInFields?: boolean;
@@ -38,7 +38,7 @@ export class ModelIndexedUtil {
   static computeIndexParts<T extends ModelType>(
     cls: Class<T>, idx: IndexConfig<T> | string, item: DeepPartial<T>, opts: ComputeConfig = {}
   ): { fields: IndexFieldPart[], sorted: IndexSortPart | undefined } {
-    const cfg = typeof idx === 'string' ? ModelRegistry.getIndex(cls, idx) : idx;
+    const cfg = typeof idx === 'string' ? ModelRegistryIndex.getIndex(cls, idx) : idx;
     const sortField = cfg.type === 'sorted' ? cfg.fields.at(-1) : undefined;
 
     const fields: IndexFieldPart[] = [];
@@ -115,7 +115,7 @@ export class ModelIndexedUtil {
   ): { type: string, key: string, sort?: number | Date } {
     const { fields, sorted } = this.computeIndexParts(cls, idx, item, { ...(opts ?? {}), includeSortInFields: false });
     const key = fields.map(({ value }) => value).map(x => `${x}`).join(opts?.sep ?? DEFAULT_SEP);
-    const cfg = typeof idx === 'string' ? ModelRegistry.getIndex(cls, idx) : idx;
+    const cfg = typeof idx === 'string' ? ModelRegistryIndex.getIndex(cls, idx) : idx;
     return !sorted ? { type: cfg.type, key } : { type: cfg.type, key, sort: sorted.value };
   }
 

package/src/util/storage.ts

@@ -1,9 +1,9 @@
 import { Class, hasFunction, Runtime } from '@travetto/runtime';
-import { SchemaChangeListener } from '@travetto/schema';
+import { SchemaChangeListener, SchemaRegistryIndex } from '@travetto/schema';
+import { Registry } from '@travetto/registry';
 
-import { ModelRegistry } from '../registry/model.ts';
 import { ModelStorageSupport } from '../types/storage.ts';
-import { ModelType } from '../types/model.ts';
+import { ModelRegistryIndex } from '../registry/registry-index.ts';
 
 /**
  * Model storage util
@@ -24,29 +24,29 @@ export class ModelStorageUtil {
     }
 
     const checkType = (cls: Class, enforceBase = true): boolean => {
-      if (enforceBase && ModelRegistry.getBaseModel(cls) !== cls) {
+      if (enforceBase && SchemaRegistryIndex.getBaseClass(cls) !== cls) {
         return false;
       }
-      const { autoCreate } = ModelRegistry.get(cls) ?? {};
-      return autoCreate;
+      const { autoCreate } = ModelRegistryIndex.getConfig(cls) ?? {};
+      return autoCreate ?? false;
     };
 
     // If listening for model add/removes/updates
     if (storage.createModel || storage.deleteModel || storage.changeModel) {
-      ModelRegistry.on<ModelType>(ev => {
+      Registry.onClassChange(ev => {
         switch (ev.type) {
-          case 'added': checkType(ev.curr!) ? storage.createModel?.(ev.curr!) : undefined; break;
-          case 'changed': checkType(ev.curr!, false) ? storage.changeModel?.(ev.curr!) : undefined; break;
-          case 'removing': checkType(ev.prev!) ? storage.deleteModel?.(ev.prev!) : undefined; break;
+          case 'added': checkType(ev.curr) ? storage.createModel?.(ev.curr) : undefined; break;
+          case 'changed': checkType(ev.curr, false) ? storage.changeModel?.(ev.curr) : undefined; break;
+          case 'removing': checkType(ev.prev) ? storage.deleteModel?.(ev.prev) : undefined; break;
         }
-      });
+      }, ModelRegistryIndex);
     }
 
     // Initialize on startup (test manages)
     await storage.createStorage();
 
     if (storage.createModel) {
-      for (const cls of ModelRegistry.getClasses()) {
+      for (const cls of ModelRegistryIndex.getClasses()) {
         if (checkType(cls)) {
           await storage.createModel(cls);
         }

package/support/base-command.ts

@@ -1,14 +1,16 @@
 import { Env } from '@travetto/runtime';
 import { CliValidationError, CliCommandShape, cliTpl } from '@travetto/cli';
-import { RootRegistry } from '@travetto/registry';
+import { Registry } from '@travetto/registry';
+import { Schema } from '@travetto/schema';
 
-import type { ModelStorageSupport } from '../src/service/storage.ts';
+import type { ModelStorageSupport } from '../src/types/storage.ts';
 
 import { ModelCandidateUtil } from './bin/candidate.ts';
 
 /**
  * CLI Entry point for exporting model schemas
  */
+@Schema()
 export abstract class BaseModelCommand implements CliCommandShape {
 
   /** Application Environment */
@@ -21,7 +23,7 @@ export abstract class BaseModelCommand implements CliCommandShape {
   }
 
   async help(): Promise<string[]> {
-    await RootRegistry.init();
+    await Registry.init();
 
     const candidates = await ModelCandidateUtil.export(this.getOp());
     return [
@@ -36,7 +38,7 @@ export abstract class BaseModelCommand implements CliCommandShape {
   }
 
   async validate(provider: string, models: string[]): Promise<CliValidationError | undefined> {
-    await RootRegistry.init();
+    await Registry.init();
 
     const candidates = await ModelCandidateUtil.export(this.getOp());
     if (provider && !candidates.providers.includes(provider)) {

package/support/bin/candidate.ts

@@ -1,9 +1,10 @@
 import { toConcrete, Class } from '@travetto/runtime';
-import { InjectableConfig, DependencyRegistry } from '@travetto/di';
+import { InjectableCandidate, DependencyRegistryIndex } from '@travetto/di';
+import { SchemaRegistryIndex } from '@travetto/schema';
 
-import { ModelRegistry } from '../../src/registry/model.ts';
 import type { ModelStorageSupport } from '../../src/types/storage.ts';
 import type { ModelType } from '../../src/types/model.ts';
+import { ModelRegistryIndex } from '../../src/registry/registry-index.ts';
 
 /**
  * Utilities for finding candidates for model operations
@@ -23,23 +24,23 @@ export class ModelCandidateUtil {
   static async #getModels(models?: string[]): Promise<Class<ModelType>[]> {
     const names = new Set(models ?? []);
     const all = names.has('*');
-    return ModelRegistry.getClasses()
-      .map(x => ModelRegistry.getBaseModel(x))
-      .filter(x => !models || all || names.has(ModelRegistry.getStore(x)));
+    return ModelRegistryIndex.getClasses()
+      .map(x => SchemaRegistryIndex.getBaseClass(x))
+      .filter(x => !models || all || names.has(ModelRegistryIndex.getStoreName(x)));
   }
 
   /**
    * Get model names
    */
   static async getModelNames(): Promise<string[]> {
-    return (await this.#getModels()).map(x => ModelRegistry.getStore(x)).toSorted();
+    return (await this.#getModels()).map(x => ModelRegistryIndex.getStoreName(x)).toSorted();
   }
 
   /**
    * Get all providers that are viable candidates
    */
-  static async getProviders(op?: keyof ModelStorageSupport): Promise<InjectableConfig[]> {
-    const types = DependencyRegistry.getCandidateTypes(toConcrete<ModelStorageSupport>());
+  static async getProviders(op?: keyof ModelStorageSupport): Promise<InjectableCandidate[]> {
+    const types = DependencyRegistryIndex.getCandidates(toConcrete<ModelStorageSupport>());
     return types.filter(x => !op || x.class.prototype?.[op]);
   }
 
@@ -57,7 +58,7 @@ export class ModelCandidateUtil {
    */
   static async getProvider(provider: string): Promise<ModelStorageSupport> {
     const config = (await this.getProviders()).find(x => x.class.name === `${provider}ModelService`)!;
-    return DependencyRegistry.getInstance<ModelStorageSupport>(config.class, config.qualifier);
+    return DependencyRegistryIndex.getInstance<ModelStorageSupport>(config.candidateType, config.qualifier);
   }
 
   /**

package/support/test/base.ts

@@ -1,4 +1,4 @@
-import { DependencyRegistry } from '@travetto/di';
+import { DependencyRegistryIndex } from '@travetto/di';
 import { AppError, castTo, Class, classConstruct } from '@travetto/runtime';
 
 import { ModelBulkUtil } from '../../src/util/bulk.ts';
@@ -49,7 +49,7 @@ export abstract class BaseModelSuite<T> {
   }
 
   get service(): Promise<T> {
-    return DependencyRegistry.getInstance(this.serviceClass);
+    return DependencyRegistryIndex.getInstance(this.serviceClass);
   }
 
   async toArray<U>(src: AsyncIterable<U> | AsyncGenerator<U>): Promise<U[]> {

package/support/test/polymorphism.ts

@@ -3,7 +3,7 @@ import timers from 'node:timers/promises';
 
 import { Suite, Test } from '@travetto/test';
 import { castTo } from '@travetto/runtime';
-import { SubTypeField, Text, TypeMismatchError } from '@travetto/schema';
+import { Schema, DiscriminatorField, Text, TypeMismatchError, Discriminated } from '@travetto/schema';
 import {
   ModelIndexedSupport, Index, ModelCrudSupport, Model,
   NotFoundError, SubTypeNotSupportedError, PersistValue
@@ -14,10 +14,11 @@ import { ExistsError } from '../../src/error/exists.ts';
 
 import { BaseModelSuite } from './base.ts';
 
-@Model({ baseType: true })
-export class Worker {
+@Schema()
+@Model()
+export abstract class Worker {
   id: string;
-  @SubTypeField()
+  @DiscriminatorField()
   _type: string;
   @Text()
   name: string;
@@ -42,19 +43,19 @@ export class Engineer extends Worker {
   major: string;
 }
 
-@Model({ baseType: true })
+@Model()
 @Index({
   name: 'worker-name',
   type: 'sorted',
   fields: [{ name: 1 }, { age: 1 }]
 })
+@Discriminated('type')
 export class IndexedWorker {
   id: string;
   type: string;
   name: string;
   age?: number;
 }
-
 @Model()
 export class IndexedDoctor extends IndexedWorker {
   specialty: string;

package/support/test/suite.ts

@@ -1,90 +1,87 @@
 import { Class } from '@travetto/runtime';
-import { DependencyRegistry } from '@travetto/di';
-import { RootRegistry } from '@travetto/registry';
-import { SuiteRegistry, TestFixtures } from '@travetto/test';
+import { DependencyRegistryIndex } from '@travetto/di';
+import { Registry } from '@travetto/registry';
+import { SuiteRegistryIndex, TestFixtures } from '@travetto/test';
+import { SchemaRegistryIndex } from '@travetto/schema';
 
 import { ModelBlobUtil } from '../../src/util/blob.ts';
 import { ModelStorageUtil } from '../../src/util/storage.ts';
-import { ModelRegistry } from '../../src/registry/model.ts';
+import { ModelRegistryIndex } from '../../src/registry/registry-index.ts';
 
 const Loaded = Symbol();
 
+/**
+ * @augments `@travetto/schema:Schema`
+ * @kind decorator
+ */
 export function ModelSuite<T extends { configClass: Class<{ autoCreate?: boolean, namespace?: string }>, serviceClass: Class }>(qualifier?: symbol) {
   const fixtures = new TestFixtures(['@travetto/model']);
   return (target: Class<T>): void => {
     target.prototype.fixtures = fixtures;
+    SuiteRegistryIndex.getForRegister(target).register({
+      beforeAll: [
+        async function (this: T & { [Loaded]?: boolean }) {
+          await Registry.init();
 
-    SuiteRegistry.registerPendingListener(
-      target,
-      async function (this: T & { [Loaded]?: boolean }) {
-        await RootRegistry.init();
-
-        if (!this[Loaded]) {
-          const config = await DependencyRegistry.getInstance(this.configClass);
-          if ('namespace' in config) {
-            config.namespace = `test_${Math.trunc(Math.random() * 10000)}`;
+          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;
           }
-          // We manually create
-          config.autoCreate = false;
-          this[Loaded] = true;
         }
-      },
-      'beforeAll'
-    );
-    SuiteRegistry.registerPendingListener(
-      target,
-      async function (this: T) {
-        const service = await DependencyRegistry.getInstance(this.serviceClass, qualifier);
-        if (ModelStorageUtil.isSupported(service)) {
-          await service.createStorage();
-          if (service.createModel) {
-            await Promise.all(ModelRegistry.getClasses()
-              .filter(x => x === ModelRegistry.getBaseModel(x))
-              .map(m => service.createModel!(m)));
+      ],
+      beforeEach: [
+        async function (this: T) {
+          const service = await DependencyRegistryIndex.getInstance(this.serviceClass, qualifier);
+          if (ModelStorageUtil.isSupported(service)) {
+            await service.createStorage();
+            if (service.createModel) {
+              await Promise.all(ModelRegistryIndex.getClasses()
+                .filter(x => x === SchemaRegistryIndex.getBaseClass(x))
+                .map(m => service.createModel!(m)));
+            }
           }
         }
-      },
-      'beforeEach'
-    );
-    SuiteRegistry.registerPendingListener(
-      target,
-      async function (this: T) {
-        const service = await DependencyRegistry.getInstance(this.serviceClass, qualifier);
-        if (ModelStorageUtil.isSupported(service)) {
-          const models = ModelRegistry.getClasses().filter(m => m === ModelRegistry.getBaseModel(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 (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
+            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
+            }
           }
         }
-      },
-      'afterEach'
-    );
-    SuiteRegistry.registerPendingListener(
-      target,
-      async function (this: T) {
-        const service = await DependencyRegistry.getInstance(this.serviceClass, qualifier);
-        if (ModelStorageUtil.isSupported(service)) {
-          if (service.deleteModel) {
-            for (const m of ModelRegistry.getClasses()) {
-              if (m === ModelRegistry.getBaseModel(m)) {
-                await service.deleteModel(m);
+      ],
+      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();
           }
-          await service.deleteStorage();
         }
-      },
-      'afterAll'
-    );
-
+      ]
+    });
   };
 }

package/src/registry/model.ts

@@ -1,218 +0,0 @@
-import { SchemaRegistry } from '@travetto/schema';
-import { MetadataRegistry } from '@travetto/registry';
-import { DependencyRegistry } from '@travetto/di';
-import { AppError, castTo, Class, describeFunction, asFull } from '@travetto/runtime';
-
-import { IndexConfig, IndexType, ModelOptions } from './types.ts';
-import { NotFoundError } from '../error/not-found.ts';
-import { ModelType } from '../types/model.ts';
-import { IndexNotSupported } from '../error/invalid-index.ts';
-
-/**
- * Registry for all models, built on the Metadata registry
- */
-class $ModelRegistry extends MetadataRegistry<ModelOptions<ModelType>> {
-  /**
-   * All stores names
-   */
-  stores = new Map<Class, string>();
-  /**
-   * All base model classes (inherited from)
-   */
-  baseModels = new Map<Class, Class>();
-  /**
-   * Indexed base model classes to all subclasses
-   */
-  baseModelGrouped = new Map<Class, Class[]>();
-  /**
-   * Default mapping of classes by class name or
-   * by requested store name.  This is the state at the
-   * start of the application.
-   */
-  initialModelNameMapping = new Map<string, Class[]>();
-
-  constructor() {
-    // Listen to schema and dependency
-    super(SchemaRegistry, DependencyRegistry);
-  }
-
-  getInitialNameMapping(): Map<string, Class[]> {
-    if (this.initialModelNameMapping.size === 0) {
-      for (const cls of this.getClasses()) {
-        const store = this.get(cls).store ?? cls.name;
-        if (!this.initialModelNameMapping.has(store)) {
-          this.initialModelNameMapping.set(store, []);
-        }
-        this.initialModelNameMapping.get(store)!.push(cls);
-      }
-    }
-    return this.initialModelNameMapping;
-  }
-
-  createPending(cls: Class): Partial<ModelOptions<ModelType>> {
-    return {
-      class: cls,
-      indices: [],
-      autoCreate: true,
-      baseType: describeFunction(cls).abstract,
-      postLoad: [],
-      prePersist: []
-    };
-  }
-
-  registerDataHandlers(cls: Class, pConfig?: Partial<ModelOptions<ModelType>>): void {
-    const cfg = this.getOrCreatePending(cls);
-    this.register(cls, {
-      ...cfg,
-      prePersist: [...cfg.prePersist ?? [], ...pConfig?.prePersist ?? []],
-      postLoad: [...cfg.postLoad ?? [], ...pConfig?.postLoad ?? []],
-    });
-  }
-
-  onInstallFinalize(cls: Class): ModelOptions<ModelType> {
-    const config = asFull(this.pending.get(cls.Ⲑid)!);
-
-    const schema = SchemaRegistry.get(cls);
-    const view = schema.totalView.schema;
-    delete view.id.required; // Allow ids to be optional
-
-    if (schema.subTypeField in view && this.getBaseModel(cls) !== cls) {
-      config.subType = !!schema.subTypeName; // Copy from schema
-      delete view[schema.subTypeField].required; // Allow type to be optional
-    }
-
-    const parent = this.getParentClass(cls);
-    if (parent && parent !== cls) {
-      const pCfg = this.get(parent) ?? this.pending.get(MetadataRegistry.id(parent));
-      config.prePersist = [...pCfg?.prePersist ?? [], ...config.prePersist ?? []];
-      config.postLoad = [...pCfg?.postLoad ?? [], ...config.postLoad ?? []];
-    }
-    return config;
-  }
-
-  override onUninstallFinalize(cls: Class): void {
-    this.stores.delete(cls);
-
-    // Force system to recompute on uninstall
-    this.baseModels.clear();
-    this.baseModelGrouped.clear();
-  }
-
-  /**
-   * Find base class for a given model
-   */
-  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;
-
-      while (conf && !conf.baseType) {
-        parent = this.getParentClass(parent)!;
-        conf = this.get(parent) ?? this.pending.get(MetadataRegistry.id(parent));
-      }
-
-      this.baseModels.set(cls, conf ? parent : cls);
-    }
-    return this.baseModels.get(cls)!;
-  }
-
-  /**
-   * Find all classes by their base types
-   */
-  getAllClassesByBaseType(): Map<Class, Class[]> {
-    if (!this.baseModelGrouped.size) {
-      const out = new Map<Class, Class[]>();
-      for (const el of this.entries.keys()) {
-        const conf = this.entries.get(el)!;
-        if (conf.baseType) {
-          continue;
-        }
-
-        const parent = this.getBaseModel(conf.class);
-
-        if (!out.has(parent)) {
-          out.set(parent, []);
-        }
-
-        out.get(parent)!.push(conf.class);
-      }
-      this.baseModelGrouped = out;
-    }
-    return this.baseModelGrouped;
-  }
-
-  /**
-   * Get all classes for a given base type
-   */
-  getClassesByBaseType(base: Class): Class[] {
-    return this.getAllClassesByBaseType().get(base) ?? [];
-  }
-
-  /**
-   * Get the apparent store for a type, handling polymorphism when appropriate
-   */
-  getStore(cls: Class): string {
-    if (!this.stores.has(cls)) {
-      const config = this.get(cls) ?? this.getOrCreatePending(cls);
-      const base = this.getBaseModel(cls);
-      if (base !== cls) {
-        return this.getStore(base);
-      }
-
-      const name = config.store ?? cls.name.toLowerCase();
-
-      const candidates = this.getInitialNameMapping().get(name) || [];
-
-      // Don't allow two models with same class name, or same store name
-      if (candidates.length > 1) {
-        if (config.store) {
-          throw new AppError('Duplicate models with same store name', {
-            details: { classes: candidates.map(x => x.Ⲑid) }
-          });
-        } else {
-          throw new AppError('Duplicate models with same class name, but no store name provided', {
-            details: { classes: candidates.map(x => x.Ⲑid) }
-          });
-        }
-      }
-
-      this.stores.set(cls, name);
-    }
-    return this.stores.get(cls)!;
-  }
-
-  /**
-   * Get Index
-   */
-  getIndex<T extends ModelType, K extends IndexType[]>(cls: Class<T>, name: string, supportedTypes?: K): IndexConfig<T> & { type: K[number] } {
-    const cfg = this.get(cls).indices?.find((x): x is IndexConfig<T> => x.name === name);
-    if (!cfg) {
-      throw new NotFoundError(`${cls.name} Index`, `${name}`);
-    }
-    if (supportedTypes && !supportedTypes.includes(cfg.type)) {
-      throw new IndexNotSupported(cls, cfg, `${cfg.type} indices are not supported.`);
-    }
-    return cfg;
-  }
-
-  /**
-   * Get Indices
-   */
-  getIndices<T extends ModelType, K extends IndexType[]>(cls: Class<T>, supportedTypes?: K): (IndexConfig<T> & { type: K[number] })[] {
-    return (this.get(cls).indices ?? []).filter((x): x is IndexConfig<T> => !supportedTypes || supportedTypes.includes(x.type));
-  }
-
-  /**
-   * Get expiry field
-   * @param cls
-   */
-  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`);
-    }
-    return castTo(expiry);
-  }
-}
-
-export const ModelRegistry = new $ModelRegistry();