@travetto/model 7.0.0-rc.1 → 7.0.0-rc.3

package/README.md

@@ -236,7 +236,7 @@ Finally, there is support for [Bulk](https://github.com/travetto/travetto/tree/m
 **Code: Bulk Contract**
 ```typescript
 export interface ModelBulkSupport extends ModelCrudSupport {
-  processBulk<T extends ModelType>(cls: Class<T>, operations: BulkOp<T>[]): Promise<BulkResponse>;
+  processBulk<T extends ModelType>(cls: Class<T>, operations: BulkOperation<T>[]): Promise<BulkResponse>;
 }
 ```
 

package/package.json

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

package/src/error/exists.ts

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

package/src/registry/decorator.ts

@@ -11,12 +11,12 @@ import { ModelRegistryIndex } from './registry-index.ts';
  * @augments `@travetto/schema:Schema`
  * @kind decorator
  */
-export function Model(conf: Partial<ModelConfig<ModelType>> | string = {}) {
+export function Model(config: Partial<ModelConfig<ModelType>> | string = {}) {
   return function <T extends ModelType, U extends Class<T>>(cls: U): U {
-    if (typeof conf === 'string') {
-      conf = { store: conf };
+    if (typeof config === 'string') {
+      config = { store: config };
     }
-    ModelRegistryIndex.getForRegister(cls).register(conf);
+    ModelRegistryIndex.getForRegister(cls).register(config);
     if (SchemaRegistryIndex.getForRegister(cls).get().fields.id) {
       SchemaRegistryIndex.getForRegister(cls).registerField('id', { required: { active: false } });
     }
@@ -29,7 +29,7 @@ export function Model(conf: Partial<ModelConfig<ModelType>> | string = {}) {
  * @kind decorator
  */
 export function Index<T extends ModelType>(...indices: IndexConfig<T>[]) {
-  if (indices.some(x => x.fields.some(f => f === 'id'))) {
+  if (indices.some(config => config.fields.some(field => field === 'id'))) {
     throw new AppError('Cannot create an index with the id field');
   }
   return function (cls: Class<T>): void {
@@ -69,7 +69,7 @@ export function PrePersist<T>(handler: DataHandler<T>, scope: PrePersistScope =
  * @augments `@travetto/schema:Field`
  * @kind decorator
  */
-export function PersistValue<T>(handler: (curr: T | undefined) => T, scope: PrePersistScope = 'all') {
+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: [{

package/src/registry/registry-adapter.ts

@@ -12,6 +12,9 @@ function combineClasses(target: ModelConfig, sources: Partial<ModelConfig>[]): M
       prePersist: [...(target.prePersist || []), ...(source.prePersist || [])],
     });
   }
+  if (target.store) {
+    target.store = target.store.toLowerCase().replace(/[^A-Za-z0-9_]+/g, '_');
+  }
   return target;
 }
 
@@ -24,16 +27,16 @@ export class ModelRegistryAdapter implements RegistryAdapter<ModelConfig> {
   }
 
   register(...data: Partial<ModelConfig>[]): ModelConfig {
-    const cfg = this.#config ??= {
+    const config = this.#config ??= {
       class: this.#cls,
       indices: [],
-      autoCreate: true,
-      store: this.#cls.name.toLowerCase(),
+      autoCreate: 'development',
+      store: this.#cls.name,
       postLoad: [],
       prePersist: []
     };
-    combineClasses(cfg, data);
-    return cfg;
+    combineClasses(config, data);
+    return config;
   }
 
   finalize(parent?: ModelConfig): void {

package/src/registry/registry-index.ts

@@ -1,4 +1,4 @@
-import { ChangeEvent, RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
+import { RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
 import { AppError, castTo, Class } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
@@ -58,7 +58,9 @@ export class ModelRegistryIndex implements RegistryIndex {
 
   store = new RegistryIndexStore(ModelRegistryAdapter);
 
-  #addClass(cls: Class): void {
+  /** @private */ constructor(source: unknown) { Registry.validateConstructor(source); }
+
+  onCreate(cls: Class): void {
     const schema = SchemaRegistryIndex.getConfig(cls);
 
     // Don't index on discriminated schemas
@@ -81,22 +83,6 @@ export class ModelRegistryIndex implements RegistryIndex {
     }
   }
 
-  #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();
   }
@@ -112,21 +98,21 @@ export class ModelRegistryIndex implements RegistryIndex {
    * 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) {
+    const config = this.getConfig(cls).indices?.find((idx): idx is IndexConfig<T> => idx.name === name);
+    if (!config) {
       throw new NotFoundError(`${cls.name} Index`, `${name}`);
     }
-    if (supportedTypes && !supportedTypes.includes(cfg.type)) {
-      throw new IndexNotSupported(cls, cfg, `${cfg.type} indices are not supported.`);
+    if (supportedTypes && !supportedTypes.includes(config.type)) {
+      throw new IndexNotSupported(cls, config, `${config.type} indices are not supported.`);
     }
-    return cfg;
+    return config;
   }
 
   /**
    * 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));
+    return (this.getConfig(cls).indices ?? []).filter((idx): idx is IndexConfig<T> => !supportedTypes || supportedTypes.includes(idx.type));
   }
 
   /**

package/src/registry/types.ts

@@ -41,9 +41,9 @@ export class ModelConfig<T extends ModelType = ModelType> {
    */
   expiresAt?: string;
   /**
-   * Auto create in development mode
+   * Allows auto creation of a model storage backing at runtime
    */
-  autoCreate?: boolean;
+  autoCreate?: 'production' | 'development' | 'off';
   /**
    * Pre-persist handlers
    */

package/src/types/bulk.ts

@@ -7,7 +7,7 @@ import { ModelType, OptionalId } from '../types/model.ts';
 /**
  * Bulk operation. Each operation has a single action and payload
  */
-export type BulkOp<T extends ModelType> =
+export type BulkOperation<T extends ModelType> =
   { delete?: T } &
   { insert?: OptionalId<T> } &
   { update?: T } &
@@ -47,9 +47,9 @@ export class BulkProcessError extends AppError<{ errors: BulkErrorItem[] }> {
     super('Bulk processing errors have occurred', {
       category: 'data',
       details: {
-        errors: errors.map(x => {
-          const { message, type, details: { errors: subErrors } = {} } = x.error;
-          return { message, type, errors: subErrors, idx: x.idx };
+        errors: errors.map(error => {
+          const { message, type, details: { errors: subErrors } = {} } = error.error;
+          return { message, type, errors: subErrors, idx: error.idx };
         })
       }
     });
@@ -62,5 +62,5 @@ export class BulkProcessError extends AppError<{ errors: BulkErrorItem[] }> {
  * @concrete
  */
 export interface ModelBulkSupport extends ModelCrudSupport {
-  processBulk<T extends ModelType>(cls: Class<T>, operations: BulkOp<T>[]): Promise<BulkResponse>;
+  processBulk<T extends ModelType>(cls: Class<T>, operations: BulkOperation<T>[]): Promise<BulkResponse>;
 }

package/src/types/storage.ts

@@ -1,5 +1,4 @@
 import { Class } from '@travetto/runtime';
-import { SchemaChange } from '@travetto/schema';
 
 import { ModelType } from '../types/model.ts';
 
@@ -15,10 +14,10 @@ import { ModelType } from '../types/model.ts';
 export interface ModelStorageSupport {
 
   /**
-   * Should auto-creation be allowed
+   * Should storage modification be allowed
    */
   readonly config?: {
-    autoCreate?: boolean;
+    modifyStorage?: boolean;
   };
 
   /**
@@ -30,29 +29,21 @@ export interface ModelStorageSupport {
    */
   deleteStorage(): Promise<void>;
   /**
-   * Installs model
+   * Creates model
    */
-  createModel?<T extends ModelType>(e: Class<T>): Promise<void>;
+  upsertModel?<T extends ModelType>(cls: Class<T>): Promise<void>;
   /**
-   * Installs model
+   * Exports model
    */
-  exportModel?<T extends ModelType>(e: Class<T>): Promise<string>;
+  exportModel?<T extends ModelType>(cls: Class<T>): Promise<string>;
   /**
-   * Installs model
+   * Deletes model
    */
-  deleteModel?<T extends ModelType>(e: Class<T>): Promise<void>;
+  deleteModel?<T extends ModelType>(cls: Class<T>): Promise<void>;
   /**
    * Removes all data from a model, but leaving the structure in place
    */
-  truncateModel?<T extends ModelType>(e: Class<T>): Promise<void>;
-  /**
-   * Deals with model internals changing
-   */
-  changeModel?<T extends ModelType>(e: Class<T>): Promise<void>;
-  /**
-   * An event listener for whenever a model schema is changed
-   */
-  changeSchema?(cls: Class, changes: SchemaChange): Promise<void>;
+  truncateModel?<T extends ModelType>(cls: Class<T>): Promise<void>;
   /**
    * Truncate blob storage data
    */

package/src/util/blob.ts

@@ -15,22 +15,22 @@ export class ModelBlobUtil {
   /**
    * Convert input to a Readable, and get what metadata is available
    */
-  static async getInput(src: BinaryInput, metadata: BlobMeta = {}): Promise<[Readable, BlobMeta]> {
-    let input: Readable;
-    if (src instanceof Blob) {
-      metadata = { ...BinaryUtil.getBlobMeta(src), ...metadata };
-      metadata.size ??= src.size;
-      input = Readable.fromWeb(src.stream());
-    } else if (typeof src === 'object' && 'pipeThrough' in src) {
-      input = Readable.fromWeb(src);
-    } else if (typeof src === 'object' && 'pipe' in src) {
-      input = src;
+  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 = src.length;
-      input = Readable.from(src);
+      metadata.size = input.length;
+      result = Readable.from(input);
     }
 
-    return [input, metadata ?? {}];
+    return [result, metadata ?? {}];
   }
 
   /**

package/src/util/bulk.ts

@@ -1,6 +1,6 @@
 import { Class, hasFunction } from '@travetto/runtime';
 
-import { BulkOp, ModelBulkSupport } from '../types/bulk.ts';
+import { BulkOperation, ModelBulkSupport } from '../types/bulk.ts';
 import { ModelType } from '../types/model.ts';
 import { ModelCrudProvider, ModelCrudUtil } from './crud.ts';
 
@@ -9,7 +9,7 @@ export type BulkPreStore<T extends ModelType> = {
   upsertedIds: Map<number, string>;
   updatedIds: Map<number, string>;
   existingUpsertedIds: Map<number, string>;
-  operations: BulkOp<T>[];
+  operations: BulkOperation<T>[];
 };
 
 export class ModelBulkUtil {
@@ -20,12 +20,12 @@ export class ModelBulkUtil {
   static isSupported = hasFunction<ModelBulkSupport>('processBulk');
 
   /**
-   * Prepares bulk ops for storage
+   * Prepares bulk operations for storage
    * @param cls
    * @param operations
    * @param provider
    */
-  static async preStore<T extends ModelType>(cls: Class<T>, operations: BulkOp<T>[], provider: ModelCrudProvider): Promise<BulkPreStore<T>> {
+  static async preStore<T extends ModelType>(cls: Class<T>, operations: BulkOperation<T>[], provider: ModelCrudProvider): Promise<BulkPreStore<T>> {
     const insertedIds = new Map<number, string>();
     const upsertedIds = new Map<number, string>();
     const updatedIds = new Map<number, string>();
@@ -33,20 +33,20 @@ export class ModelBulkUtil {
 
     // Pre store
     let i = 0;
-    for (const op of operations) {
-      if ('insert' in op && op.insert) {
-        op.insert = await ModelCrudUtil.preStore(cls, op.insert, provider);
-        insertedIds.set(i, op.insert.id!);
-      } else if ('update' in op && op.update) {
-        op.update = await ModelCrudUtil.preStore(cls, op.update, provider);
-        updatedIds.set(i, op.update.id);
-      } else if ('upsert' in op && op.upsert) {
-        const isNew = !op.upsert.id;
-        op.upsert = await ModelCrudUtil.preStore(cls, op.upsert, provider);
+    for (const operation of operations) {
+      if ('insert' in operation && operation.insert) {
+        operation.insert = await ModelCrudUtil.preStore(cls, operation.insert, provider);
+        insertedIds.set(i, operation.insert.id!);
+      } else if ('update' in operation && operation.update) {
+        operation.update = await ModelCrudUtil.preStore(cls, operation.update, provider);
+        updatedIds.set(i, operation.update.id);
+      } else if ('upsert' in operation && operation.upsert) {
+        const isNew = !operation.upsert.id;
+        operation.upsert = await ModelCrudUtil.preStore(cls, operation.upsert, provider);
         if (isNew) {
-          upsertedIds.set(i, op.upsert.id!);
+          upsertedIds.set(i, operation.upsert.id!);
         } else {
-          existingUpsertedIds.set(i, op.upsert.id!);
+          existingUpsertedIds.set(i, operation.upsert.id!);
         }
       }
       i += 1;

package/src/util/crud.ts

@@ -1,4 +1,4 @@
-import { castTo, Class, Util, AppError, hasFunction } from '@travetto/runtime';
+import { castTo, Class, Util, AppError, hasFunction, JSONUtil } from '@travetto/runtime';
 import { DataUtil, SchemaRegistryIndex, SchemaValidator, ValidationError, ValidationResultError } from '@travetto/schema';
 
 import { ModelRegistryIndex } from '../registry/registry-index.ts';
@@ -26,9 +26,9 @@ export class ModelCrudUtil {
   /**
    * Build a uuid generator
    */
-  static uuidSource(len: number = 32): ModelIdSource {
-    const create = (): string => Util.uuid(len);
-    const valid = (id: string): boolean => id.length === len && /^[0-9a-f]+$/i.test(id);
+  static uuidSource(length: number = 32): ModelIdSource {
+    const create = (): string => Util.uuid(length);
+    const valid = (id: string): boolean => id.length === length && /^[0-9a-f]+$/i.test(id);
     return { create, valid };
   }
 
@@ -39,10 +39,8 @@ export class ModelCrudUtil {
    */
   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') {
-      resolvedInput = JSON.parse(input);
-    } else if (input instanceof Buffer) {
-      resolvedInput = JSON.parse(input.toString('utf8'));
+    if (typeof input === 'string' || input instanceof Buffer) {
+      resolvedInput = JSONUtil.parseSafe(input);
     } else {
       resolvedInput = input;
     }
@@ -82,9 +80,9 @@ export class ModelCrudUtil {
     let errors: ValidationError[] = [];
     try {
       await SchemaValidator.validate(cls, item);
-    } catch (err) {
-      if (err instanceof ValidationResultError) {
-        errors = err.details.errors;
+    } catch (error) {
+      if (error instanceof ValidationResultError) {
+        errors = error.details.errors;
       }
     }
 
@@ -153,9 +151,9 @@ export class ModelCrudUtil {
       item = { ...item };
       delete item.id;
     }
-    const res = await this.prePersist(cls, castTo(item), 'partial');
+    const result = await this.prePersist(cls, castTo(item), 'partial');
     await SchemaValidator.validatePartial(cls, item, view);
-    return res;
+    return result;
   }
 
   /**

package/src/util/expiry.ts

@@ -29,13 +29,13 @@ export class ModelExpiryUtil {
 
   /**
    * Delete all expired on a fixed interval, if supported and needed
-   * @param svc
+   * @param service
    */
-  static registerCull(svc: ModelExpirySupport & { readonly config?: { cullRate?: number | TimeSpan } }): void {
+  static registerCull(service: ModelExpirySupport & { readonly config?: { cullRate?: number | TimeSpan } }): void {
     const cullable = ModelRegistryIndex.getClasses().filter(cls => !!ModelRegistryIndex.getConfig(cls).expiresAt);
-    if (svc.deleteExpired && cullable.length) {
+    if (service.deleteExpired && cullable.length) {
       const running = new AbortController();
-      const cullInterval = TimeUtil.asMillis(svc.config?.cullRate ?? '10m');
+      const cullInterval = TimeUtil.asMillis(service.config?.cullRate ?? '10m');
 
       ShutdownManager.onGracefulShutdown(async () => running.abort());
 
@@ -43,7 +43,7 @@ export class ModelExpiryUtil {
         await Util.nonBlockingTimeout(1000);
         while (!running.signal.aborted) {
           await Util.nonBlockingTimeout(cullInterval);
-          await Promise.all(cullable.map(cls => svc.deleteExpired(cls)));
+          await Promise.all(cullable.map(cls => service.deleteExpired(cls)));
         }
       })();
     }

package/src/util/indexed.ts

@@ -38,43 +38,43 @@ 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' ? ModelRegistryIndex.getIndex(cls, idx) : idx;
-    const sortField = cfg.type === 'sorted' ? cfg.fields.at(-1) : undefined;
+    const config = typeof idx === 'string' ? ModelRegistryIndex.getIndex(cls, idx) : idx;
+    const sortField = config.type === 'sorted' ? config.fields.at(-1) : undefined;
 
     const fields: IndexFieldPart[] = [];
-    let sortDir: number = 0;
+    let sortDirection: number = 0;
     let sorted: IndexSortPart | undefined;
 
-    for (const field of cfg.fields) {
-      let f: Record<string, unknown> = field;
-      let o: Record<string, unknown> = item;
+    for (const field of config.fields) {
+      let fieldRef: Record<string, unknown> = field;
+      let itemRef: Record<string, unknown> = item;
       const parts = [];
 
-      while (o !== undefined && o !== null) {
-        const k = TypedObject.keys(f)[0];
-        o = castTo(o[k]);
-        parts.push(k);
-        if (typeof f[k] === 'boolean' || typeof f[k] === 'number') {
-          if (cfg.type === 'sorted') {
-            sortDir = f[k] === true ? 1 : f[k] === false ? 0 : f[k];
+      while (itemRef !== undefined && itemRef !== null) {
+        const key = TypedObject.keys(fieldRef)[0];
+        itemRef = castTo(itemRef[key]);
+        parts.push(key);
+        if (typeof fieldRef[key] === 'boolean' || typeof fieldRef[key] === 'number') {
+          if (config.type === 'sorted') {
+            sortDirection = fieldRef[key] === true ? 1 : fieldRef[key] === false ? 0 : fieldRef[key];
           }
           break; // At the bottom
         } else {
-          f = castTo(f[k]);
+          fieldRef = castTo(fieldRef[key]);
         }
       }
       if (field === sortField) {
-        sorted = { path: parts, dir: sortDir, value: castTo(o) };
+        sorted = { path: parts, dir: sortDirection, value: castTo(itemRef) };
       }
-      if (o === undefined || o === null) {
+      if (itemRef === undefined || itemRef === null) {
         const empty = field === sortField ? opts.emptySortValue : opts.emptyValue;
         if (empty === undefined || empty === Error) {
-          throw new IndexNotSupported(cls, cfg, `Missing field value for ${parts.join('.')}`);
+          throw new IndexNotSupported(cls, config, `Missing field value for ${parts.join('.')}`);
         }
-        o = castTo(empty!);
+        itemRef = castTo(empty!);
       } else {
         if (field !== sortField || (opts.includeSortInFields ?? true)) {
-          fields.push({ path: parts, value: castTo(o) });
+          fields.push({ path: parts, value: castTo(itemRef) });
         }
       }
     }
@@ -87,18 +87,18 @@ export class ModelIndexedUtil {
    * @param cls Type to get index for
    * @param idx Index config
    */
-  static projectIndex<T extends ModelType>(cls: Class<T>, idx: IndexConfig<T> | string, item?: DeepPartial<T>, cfg?: ComputeConfig): Record<string, unknown> {
-    const res: Record<string, unknown> = {};
-    for (const { path, value } of this.computeIndexParts(cls, idx, item ?? {}, cfg).fields) {
-      let sub: Record<string, unknown> = res;
+  static projectIndex<T extends ModelType>(cls: Class<T>, idx: IndexConfig<T> | string, item?: DeepPartial<T>, config?: ComputeConfig): Record<string, unknown> {
+    const response: Record<string, unknown> = {};
+    for (const { path, value } of this.computeIndexParts(cls, idx, item ?? {}, config).fields) {
+      let sub: Record<string, unknown> = response;
       const all = path.slice(0);
       const last = all.pop()!;
-      for (const k of all) {
-        sub = castTo(sub[k] ??= {});
+      for (const part of all) {
+        sub = castTo(sub[part] ??= {});
       }
       sub[last] = value;
     }
-    return res;
+    return response;
   }
 
   /**
@@ -111,12 +111,12 @@ export class ModelIndexedUtil {
     cls: Class<T>,
     idx: IndexConfig<T> | string,
     item: DeepPartial<T> = {},
-    opts?: ComputeConfig & { sep?: string }
+    config?: ComputeConfig & { separator?: string }
   ): { 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' ? ModelRegistryIndex.getIndex(cls, idx) : idx;
-    return !sorted ? { type: cfg.type, key } : { type: cfg.type, key, sort: sorted.value };
+    const { fields, sorted } = this.computeIndexParts(cls, idx, item, { ...(config ?? {}), includeSortInFields: false });
+    const key = fields.map(({ value }) => value).map(value => `${value}`).join(config?.separator ?? DEFAULT_SEP);
+    const indexConfig = typeof idx === 'string' ? ModelRegistryIndex.getIndex(cls, idx) : idx;
+    return !sorted ? { type: indexConfig.type, key } : { type: indexConfig.type, key, sort: sorted.value };
   }
 
   /**
@@ -134,11 +134,11 @@ export class ModelIndexedUtil {
       const { id } = await service.getByIndex(cls, idx, castTo(body));
       body.id = id;
       return await service.update(cls, castTo(body));
-    } catch (err) {
-      if (err instanceof NotFoundError) {
+    } catch (error) {
+      if (error instanceof NotFoundError) {
         return await service.create(cls, body);
       } else {
-        throw err;
+        throw error;
       }
     }
   }

package/src/util/storage.ts

@@ -1,6 +1,5 @@
 import { Class, hasFunction, Runtime } from '@travetto/runtime';
-import { SchemaChangeListener, SchemaRegistryIndex } from '@travetto/schema';
-import { Registry } from '@travetto/registry';
+import { SchemaRegistryIndex } from '@travetto/schema';
 
 import { ModelStorageSupport } from '../types/storage.ts';
 import { ModelRegistryIndex } from '../registry/registry-index.ts';
@@ -16,10 +15,10 @@ export class ModelStorageUtil {
   static isSupported = hasFunction<ModelStorageSupport>('createStorage');
 
   /**
-   * Register change listener on startup
+   * Storage Initialization
    */
-  static async registerModelChangeListener(storage: ModelStorageSupport): Promise<void> {
-    if (!Runtime.dynamic || !(storage?.config?.autoCreate ?? !Runtime.production)) {
+  static async storageInitialization(storage: ModelStorageSupport): Promise<void> {
+    if (storage.config?.modifyStorage === false) {
       return;
     }
 
@@ -27,39 +26,25 @@ export class ModelStorageUtil {
       if (enforceBase && SchemaRegistryIndex.getBaseClass(cls) !== cls) {
         return false;
       }
+
       const { autoCreate } = ModelRegistryIndex.getConfig(cls) ?? {};
-      return autoCreate ?? false;
-    };
 
-    // If listening for model add/removes/updates
-    if (storage.createModel || storage.deleteModel || storage.changeModel) {
-      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;
-        }
-      }, ModelRegistryIndex);
-    }
+      if (autoCreate === 'off') {
+        return false;
+      }
+
+      return (autoCreate === 'production' || !Runtime.production);
+    };
 
     // Initialize on startup (test manages)
     await storage.createStorage();
 
-    if (storage.createModel) {
+    if (storage.upsertModel) {
       for (const cls of ModelRegistryIndex.getClasses()) {
         if (checkType(cls)) {
-          await storage.createModel(cls);
+          await storage.upsertModel(cls);
         }
       }
     }
-
-    // If listening for model add/removes/updates
-    if (storage.changeSchema) {
-      SchemaChangeListener.onSchemaChange(ev => {
-        if (checkType(ev.cls)) {
-          storage.changeSchema!(ev.cls, ev.change);
-        }
-      });
-    }
   }
 }

package/support/base-command.ts

@@ -16,7 +16,7 @@ export abstract class BaseModelCommand implements CliCommandShape {
   /** Application Environment */
   env?: string;
 
-  abstract getOp(): keyof ModelStorageSupport;
+  abstract getOperation(): keyof ModelStorageSupport;
 
   preMain(): void {
     Env.DEBUG.set(false);
@@ -25,26 +25,26 @@ export abstract class BaseModelCommand implements CliCommandShape {
   async help(): Promise<string[]> {
     await Registry.init();
 
-    const candidates = await ModelCandidateUtil.export(this.getOp());
+    const candidates = await ModelCandidateUtil.export(this.getOperation());
     return [
       cliTpl`${{ title: 'Providers' }}`,
       '-'.repeat(20),
-      ...candidates.providers.map(p => cliTpl`  * ${{ type: p }}`),
+      ...candidates.providers.map(type => cliTpl`  * ${{ type }}`),
       '',
       cliTpl`${{ title: 'Models' }}`,
       '-'.repeat(20),
-      ...candidates.models.map(p => cliTpl`  * ${{ param: p }}`)
+      ...candidates.models.map(param => cliTpl`  * ${{ param }}`)
     ];
   }
 
   async validate(provider: string, models: string[]): Promise<CliValidationError | undefined> {
     await Registry.init();
 
-    const candidates = await ModelCandidateUtil.export(this.getOp());
+    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(x => x !== '*' && !candidates.models.includes(x));
+    const badModel = models.find(model => model !== '*' && !candidates.models.includes(model));
     if (badModel) {
       return { message: `model: ${badModel} is not a valid model`, source: 'arg' };
     }

package/support/bin/candidate.ts

@@ -11,10 +11,10 @@ import { ModelRegistryIndex } from '../../src/registry/registry-index.ts';
  */
 export class ModelCandidateUtil {
 
-  static async export(op: keyof ModelStorageSupport): Promise<{ models: string[], providers: string[] }> {
+  static async export(operation: keyof ModelStorageSupport): Promise<{ models: string[], providers: string[] }> {
     return {
       models: await this.getModelNames(),
-      providers: await this.getProviderNames(op)
+      providers: await this.getProviderNames(operation)
     };
   }
 
@@ -25,30 +25,30 @@ export class ModelCandidateUtil {
     const names = new Set(models ?? []);
     const all = names.has('*');
     return ModelRegistryIndex.getClasses()
-      .map(x => SchemaRegistryIndex.getBaseClass(x))
-      .filter(x => !models || all || names.has(ModelRegistryIndex.getStoreName(x)));
+      .map(cls => SchemaRegistryIndex.getBaseClass(cls))
+      .filter(cls => !models || all || names.has(ModelRegistryIndex.getStoreName(cls)));
   }
 
   /**
    * Get model names
    */
   static async getModelNames(): Promise<string[]> {
-    return (await this.#getModels()).map(x => ModelRegistryIndex.getStoreName(x)).toSorted();
+    return (await this.#getModels()).map(cls => ModelRegistryIndex.getStoreName(cls)).toSorted();
   }
 
   /**
    * Get all providers that are viable candidates
    */
-  static async getProviders(op?: keyof ModelStorageSupport): Promise<InjectableCandidate[]> {
-    const types = DependencyRegistryIndex.getCandidates(toConcrete<ModelStorageSupport>());
-    return types.filter(x => !op || x.class.prototype?.[op]);
+  static async getProviders(operation?: keyof ModelStorageSupport): Promise<InjectableCandidate[]> {
+    const candidates = DependencyRegistryIndex.getCandidates(toConcrete<ModelStorageSupport>());
+    return candidates.filter(type => !operation || type.class.prototype?.[operation]);
   }
 
   /**
    * Get list of names of all viable providers
    */
-  static async getProviderNames(op?: keyof ModelStorageSupport): Promise<string[]> {
-    return (await this.getProviders(op))
+  static async getProviderNames(operation?: keyof ModelStorageSupport): Promise<string[]> {
+    return (await this.getProviders(operation))
       .map(x => x.class.name.replace(/ModelService/, ''))
       .toSorted();
   }
@@ -57,7 +57,7 @@ export class ModelCandidateUtil {
    * Get a single provider
    */
   static async getProvider(provider: string): Promise<ModelStorageSupport> {
-    const config = (await this.getProviders()).find(x => x.class.name === `${provider}ModelService`)!;
+    const config = (await this.getProviders()).find(candidates => candidates.class.name === `${provider}ModelService`)!;
     return DependencyRegistryIndex.getInstance<ModelStorageSupport>(config.candidateType, config.qualifier);
   }
 

package/support/bin/install.ts

@@ -3,12 +3,12 @@ import type { ModelStorageSupport, ModelType } from '@travetto/model';
 
 export class ModelInstallUtil {
   static async run(provider: ModelStorageSupport, models: Class<ModelType>[]): Promise<void> {
-    if (!provider.createModel) {
+    if (!provider.upsertModel) {
       throw new Error(`${provider} does not support model installation`);
     }
-    for (const m of models) {
-      console.log('Installing', { name: m.Ⲑid });
-      await provider.createModel(m);
+    for (const cls of models) {
+      console.log('Installing', { name: cls.Ⲑid });
+      await provider.upsertModel(cls);
     }
   }
 }

package/support/cli.model_export.ts

@@ -10,7 +10,7 @@ import { ModelCandidateUtil } from './bin/candidate.ts';
 @CliCommand({ with: { env: true, module: true } })
 export class ModelExportCommand extends BaseModelCommand {
 
-  getOp(): 'exportModel' { return 'exportModel'; }
+  getOperation(): 'exportModel' { return 'exportModel'; }
 
   async main(provider: string, models: string[]): Promise<void> {
     const resolved = await ModelCandidateUtil.resolve(provider, models);

package/support/cli.model_install.ts

@@ -10,7 +10,7 @@ import { ModelCandidateUtil } from './bin/candidate.ts';
 @CliCommand({ with: { env: true, module: true } })
 export class ModelInstallCommand extends BaseModelCommand {
 
-  getOp(): 'createModel' { return 'createModel'; }
+  getOperation(): 'upsertModel' { return 'upsertModel'; }
 
   async main(provider: string, models: string[]): Promise<void> {
     const resolved = await ModelCandidateUtil.resolve(provider, models);

package/support/doc.support.tsx

@@ -34,18 +34,18 @@ export const ModelTypes = (fn: | Function): DocJSXElement[] => {
       found.push(link);
     }
   }
-  return found.map(v => <li>{v}</li>);
+  return found.map(type => <li>{type}</li>);
 };
 
-export const ModelCustomConfig = ({ cfg }: { cfg: Function }): DocJSXElement => <>
+export const ModelCustomConfig = ({ config }: { config: Function }): DocJSXElement => <>
   Out of the box, by installing the module, everything should be wired up by default.If you need to customize any aspect of the source
   or config, you can override and register it with the {d.mod('Di')} module.
 
   <c.Code title='Wiring up a custom Model Source' src='doc/custom-service.ts' />
 
-  where the {cfg} is defined by:
+  where the {config} is defined by:
 
-  <c.Code title={`Structure of ${cfg.name}`} src={cfg} startRe={/@Config/} />
+  <c.Code title={`Structure of ${config.name}`} src={config} startRe={/@Config/} />
 
   Additionally, you can see that the class is registered with the {Config} annotation, and so these values can be overridden using the
   standard {d.mod('Config')}resolution paths.

package/support/test/suite.ts

@@ -39,10 +39,10 @@ export function ModelSuite<T extends { configClass: Class<{ autoCreate?: boolean
           const service = await DependencyRegistryIndex.getInstance(this.serviceClass, qualifier);
           if (ModelStorageUtil.isSupported(service)) {
             await service.createStorage();
-            if (service.createModel) {
+            if (service.upsertModel) {
               await Promise.all(ModelRegistryIndex.getClasses()
                 .filter(x => x === SchemaRegistryIndex.getBaseClass(x))
-                .map(m => service.createModel!(m)));
+                .map(m => service.upsertModel!(m)));
             }
           }
         }