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

package/README.md

@@ -36,8 +36,8 @@ export class Init {
   @InjectableFactory({
     primary: true
   })
-  static getModelSource(conf: ElasticsearchModelConfig) {
-    return new ElasticsearchModelService(conf);
+  static getModelSource(config: ElasticsearchModelConfig) {
+    return new ElasticsearchModelService(config);
   }
 }
 ```
@@ -65,9 +65,9 @@ export class ElasticsearchModelConfig {
    */
   namespace = 'app';
   /**
-   * Auto-create, disabled in prod by default
+   * Allow storage modifification
    */
-  autoCreate?: boolean;
+  modifyStorage?: boolean;
   /**
    * Should we store the id as a string in the document
    */
@@ -99,8 +99,8 @@ export class ElasticsearchModelConfig {
   postConstruct(): void {
     console.debug('Constructed', { config: this });
     this.hosts = this.hosts
-      .map(x => x.includes(':') ? x : `${x}:${this.port}`)
-      .map(x => x.startsWith('http') ? x : `http://${x}`);
+      .map(host => host.includes(':') ? host : `${host}:${this.port}`)
+      .map(host => host.startsWith('http') ? host : `http://${host}`);
   }
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-elasticsearch",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.3",
   "description": "Elasticsearch backing for the travetto model module, with real-time modeling support for Elasticsearch mappings.",
   "keywords": [
     "elasticsearch",
@@ -28,10 +28,10 @@
   },
   "dependencies": {
     "@elastic/elasticsearch": "^9.2.0",
-    "@travetto/cli": "^7.0.0-rc.1",
-    "@travetto/config": "^7.0.0-rc.1",
-    "@travetto/model": "^7.0.0-rc.1",
-    "@travetto/model-query": "^7.0.0-rc.1"
+    "@travetto/cli": "^7.0.0-rc.3",
+    "@travetto/config": "^7.0.0-rc.3",
+    "@travetto/model": "^7.0.0-rc.3",
+    "@travetto/model-query": "^7.0.0-rc.3"
   },
   "travetto": {
     "displayName": "Elasticsearch Model Source"

package/src/config.ts

@@ -25,9 +25,9 @@ export class ElasticsearchModelConfig {
    */
   namespace = 'app';
   /**
-   * Auto-create, disabled in prod by default
+   * Allow storage modifification
    */
-  autoCreate?: boolean;
+  modifyStorage?: boolean;
   /**
    * Should we store the id as a string in the document
    */
@@ -59,7 +59,7 @@ export class ElasticsearchModelConfig {
   postConstruct(): void {
     console.debug('Constructed', { config: this });
     this.hosts = this.hosts
-      .map(x => x.includes(':') ? x : `${x}:${this.port}`)
-      .map(x => x.startsWith('http') ? x : `http://${x}`);
+      .map(host => host.includes(':') ? host : `${host}:${this.port}`)
+      .map(host => host.startsWith('http') ? host : `http://${host}`);
   }
 }

package/src/index-manager.ts

@@ -2,7 +2,6 @@ import { Client, estypes } from '@elastic/elasticsearch';
 
 import { Class } from '@travetto/runtime';
 import { ModelRegistryIndex, ModelType, ModelStorageSupport } from '@travetto/model';
-import { SchemaChange, SchemaRegistryIndex } from '@travetto/schema';
 
 import { ElasticsearchModelConfig } from './config.ts';
 import { ElasticsearchSchemaUtil } from './internal/schema.ts';
@@ -12,8 +11,6 @@ import { ElasticsearchSchemaUtil } from './internal/schema.ts';
  */
 export class IndexManager implements ModelStorageSupport {
 
-  #indexToAlias = new Map<string, string>();
-  #aliasToIndex = new Map<string, string>();
   #identities = new Map<Class, { index: string }>();
   #client: Client;
   config: ElasticsearchModelConfig;
@@ -24,7 +21,7 @@ export class IndexManager implements ModelStorageSupport {
   }
 
   getStore(cls: Class): string {
-    return ModelRegistryIndex.getStoreName(cls).toLowerCase().replace(/[^A-Za-z0-9_]+/g, '_');
+    return ModelRegistryIndex.getStoreName(cls);
   }
 
   /**
@@ -51,22 +48,6 @@ export class IndexManager implements ModelStorageSupport {
     return { ...this.#identities.get(cls)! };
   }
 
-  /**
-   * Build alias mappings from the current state in the database
-   */
-  async computeAliasMappings(force = false): Promise<void> {
-    if (force || !this.#indexToAlias.size) {
-      const aliases = await this.#client.cat.aliases({ format: 'json' });
-
-      this.#indexToAlias = new Map();
-      this.#aliasToIndex = new Map();
-      for (const al of aliases) {
-        this.#indexToAlias.set(al.index!, al.alias!);
-        this.#aliasToIndex.set(al.alias!, al.index!);
-      }
-    }
-  }
-
   /**
    * Create index for type
    * @param cls
@@ -74,126 +55,87 @@ export class IndexManager implements ModelStorageSupport {
    */
   async createIndex(cls: Class, alias = true): Promise<string> {
     const mapping = ElasticsearchSchemaUtil.generateSchemaMapping(cls, this.config.schemaConfig);
-    const ident = this.getIdentity(cls); // Already namespaced
-    const concreteIndex = `${ident.index}_${Date.now()}`;
+    const { index } = this.getIdentity(cls); // Already namespaced
+    const concreteIndex = `${index}_${Date.now()}`;
     try {
       await this.#client.indices.create({
         index: concreteIndex,
         mappings: mapping,
         settings: this.config.indexCreate,
-        ...(alias ? { aliases: { [ident.index]: {} } } : {})
+        ...(alias ? { aliases: { [index]: {} } } : {})
       });
-      console.debug('Index created', { index: ident.index, concrete: concreteIndex });
+      console.debug('Index created', { index, concrete: concreteIndex });
       console.debug('Index Config', {
         mappings: mapping,
         settings: this.config.indexCreate
       });
-    } catch (err) {
-      console.warn('Index already created', { index: ident.index, error: err });
+    } catch (error) {
+      console.warn('Index already created', { index, error });
     }
     return concreteIndex;
   }
 
-  /**
-   * Build an index if missing
-   */
-  async createIndexIfMissing(cls: Class): Promise<void> {
-    const baseCls = SchemaRegistryIndex.getBaseClass(cls);
-    const ident = this.getIdentity(baseCls);
-    try {
-      await this.#client.search(ident);
-    } catch {
-      await this.createIndex(baseCls);
-    }
-  }
-
-  async createModel(cls: Class<ModelType>): Promise<void> {
-    await this.createIndexIfMissing(cls);
-    await this.computeAliasMappings(true);
-  }
-
   async exportModel(cls: Class<ModelType>): Promise<string> {
     const schema = ElasticsearchSchemaUtil.generateSchemaMapping(cls, this.config.schemaConfig);
-    const ident = this.getIdentity(cls); // Already namespaced
-    return `curl -XPOST $ES_HOST/${ident.index} -d '${JSON.stringify({
+    const { index } = this.getIdentity(cls); // Already namespaced
+    return `curl -XPOST $ES_HOST/${index} -d '${JSON.stringify({
       mappings: schema,
       settings: this.config.indexCreate
     })}'`;
   }
 
   async deleteModel(cls: Class<ModelType>): Promise<void> {
-    const alias = this.getNamespacedIndex(this.getStore(cls));
-    if (this.#aliasToIndex.get(alias)) {
-      await this.#client.indices.delete({
-        index: this.#aliasToIndex.get(alias)!
-      });
-      await this.computeAliasMappings(true);
-    }
+    const { index } = this.getIdentity(cls);
+    const aliasedIndices = await this.#client.indices.getAlias();
+
+    const toDelete = Object.keys(aliasedIndices[index]?.aliases ?? {})
+      .filter(item => index in (aliasedIndices[item]?.aliases ?? {}));
+
+    console.debug('Deleting Model', { index, toDelete });
+    await Promise.all(toDelete.map(target => this.#client.indices.delete({ index: target })));
   }
 
   /**
-   * When the schema changes
+   * Create or update schema as necessary
    */
-  async changeSchema(cls: Class, change: SchemaChange): Promise<void> {
-    // Find which fields are gone
-    const removes = change.subs.reduce<string[]>((acc, v) => {
-      acc.push(...v.fields
-        .filter(ev => ev.type === 'removing')
-        .map(ev => [...v.path.map(f => f.name), ev.prev!.name].join('.')));
-      return acc;
-    }, []);
-
-    // Find which types have changed
-    const fieldChanges = change.subs.reduce<string[]>((acc, v) => {
-      acc.push(...v.fields
-        .filter(ev => ev.type === 'changed')
-        .filter(ev => ev.prev?.type !== ev.curr?.type)
-        .map(ev => [...v.path.map(f => f.name), ev.prev!.name].join('.')));
-      return acc;
-    }, []);
-
+  async upsertModel(cls: Class<ModelType>): Promise<void> {
     const { index } = this.getIdentity(cls);
-
-    // If removing fields or changing types, run as script to update data
-    if (removes.length || fieldChanges.length) { // Removing and adding
-      const next = await this.createIndex(cls, false);
-
-      const aliases = (await this.#client.indices.getAlias({ index })).body;
-      const curr = Object.keys(aliases)[0];
-
-      const allChange = removes.concat(fieldChanges);
-
-      const reindexBody: estypes.ReindexRequest = {
-        source: { index: curr },
-        dest: { index: next },
-        script: {
-          lang: 'painless',
-          source: allChange.map(x => `ctx._source.remove("${x}");`).join(' ') // Removing
-        },
-        wait_for_completion: true
-      };
-
-      // Reindex
-      await this.#client.reindex(reindexBody);
-
-      await Promise.all(Object.keys(aliases)
-        .map(x => this.#client.indices.delete({ index: x })));
-
-      await this.#client.indices.putAlias({ index: next, name: index });
-    } else { // Only update the schema
-      const schema = ElasticsearchSchemaUtil.generateSchemaMapping(cls, this.config.schemaConfig);
-
-      await this.#client.indices.putMapping({
-        index,
-        ...schema,
-      });
+    const resolvedAlias = await this.#client.indices.getMapping({ index }).catch(() => undefined);
+
+    if (resolvedAlias) {
+      const [currentIndex] = Object.keys(resolvedAlias ?? {});
+      const pendingMapping = ElasticsearchSchemaUtil.generateSchemaMapping(cls, this.config.schemaConfig);
+      const changedFields = ElasticsearchSchemaUtil.getChangedFields(resolvedAlias[currentIndex].mappings, pendingMapping);
+
+      if (changedFields.length) { // If any fields changed, reindex
+        console.debug('Updated Model', { index, currentIndex, changedFields });
+        const pendingIndex = await this.createIndex(cls, false);
+
+        const reindexBody: estypes.ReindexRequest = {
+          source: { index: currentIndex },
+          dest: { index: pendingIndex },
+          script: {
+            lang: 'painless',
+            source: changedFields.map(change => `ctx._source.remove("${change}");`).join(' ') // Removing
+          },
+          wait_for_completion: true
+        };
+
+        await this.#client.reindex(reindexBody);
+
+        // Update aliases
+        await this.#client.indices.putAlias({ index: pendingIndex, name: index });
+        const toDelete = Object.keys(resolvedAlias).filter(item => item !== pendingIndex);
+        await Promise.all(toDelete.map(alias => this.#client.indices.delete({ index: alias })));
+      }
+    } else { // Create if non-existent
+      console.debug('Creating Model', { index });
+      await this.createIndex(cls);
     }
   }
 
   async createStorage(): Promise<void> {
-    // Pre-create indexes if missing
     console.debug('Create Storage', { idx: this.getNamespacedIndex('*') });
-    await this.computeAliasMappings(true);
   }
 
   async deleteStorage(): Promise<void> {
@@ -201,6 +143,5 @@ export class IndexManager implements ModelStorageSupport {
     await this.#client.indices.delete({
       index: this.getNamespacedIndex('*')
     });
-    await this.computeAliasMappings(true);
   }
 }

package/src/internal/query.ts

@@ -15,15 +15,15 @@ export class ElasticsearchQueryUtil {
   /**
    * Convert `a.b.c` to `a : { b : { c : ... }}`
    */
-  static extractSimple<T>(o: T, path: string = ''): Record<string, unknown> {
+  static extractSimple<T>(input: T, path: string = ''): Record<string, unknown> {
     const out: Record<string, unknown> = {};
-    const keys = TypedObject.keys(o);
+    const keys = TypedObject.keys(input);
     for (const key of keys) {
       const subPath = `${path}${key}`;
-      if (DataUtil.isPlainObject(o[key]) && !Object.keys(o[key])[0].startsWith('$')) {
-        Object.assign(out, this.extractSimple(o[key], `${subPath}.`));
+      if (DataUtil.isPlainObject(input[key]) && !Object.keys(input[key])[0].startsWith('$')) {
+        Object.assign(out, this.extractSimple(input[key], `${subPath}.`));
       } else {
-        out[subPath] = o[key];
+        out[subPath] = input[key];
       }
     }
     return out;
@@ -36,13 +36,13 @@ export class ElasticsearchQueryUtil {
     const simp = this.extractSimple(clause);
     const include: string[] = [];
     const exclude: string[] = [];
-    for (const k of Object.keys(simp)) {
-      const nk = k === 'id' ? '_id' : k;
-      const v: 1 | 0 | boolean = castTo(simp[k]);
-      if (v === 0 || v === false) {
-        exclude.push(nk);
+    for (const key of Object.keys(simp)) {
+      const translatedKey = key === 'id' ? '_id' : key;
+      const value: 1 | 0 | boolean = castTo(simp[key]);
+      if (value === 0 || value === false) {
+        exclude.push(translatedKey);
       } else {
-        include.push(nk);
+        include.push(translatedKey);
       }
     }
     return [include, exclude];
@@ -52,73 +52,73 @@ export class ElasticsearchQueryUtil {
    * Build sort mechanism
    */
   static getSort<T extends ModelType>(sort: SortClause<T>[] | IndexConfig<T>['fields']): estypes.Sort {
-    return sort.map<estypes.SortOptions>(x => {
-      const o = this.extractSimple(x);
-      const k = Object.keys(o)[0];
-      const v: boolean | -1 | 1 = castTo(o[k]);
-      return { [k]: { order: v === 1 || v === true ? 'asc' : 'desc' } };
+    return sort.map<estypes.SortOptions>(option => {
+      const item = this.extractSimple(option);
+      const key = Object.keys(item)[0];
+      const value: boolean | -1 | 1 = castTo(item[key]);
+      return { [key]: { order: value === 1 || value === true ? 'asc' : 'desc' } };
     });
   }
 
   /**
    * Extract specific term for a class, and a given field
    */
-  static extractWhereTermQuery<T>(cls: Class<T>, o: Record<string, unknown>, config?: EsSchemaConfig, path: string = ''): Record<string, unknown> {
+  static extractWhereTermQuery<T>(cls: Class<T>, item: Record<string, unknown>, config?: EsSchemaConfig, path: string = ''): Record<string, unknown> {
     const items = [];
     const fields = SchemaRegistryIndex.get(cls).getFields();
 
-    for (const key of TypedObject.keys(o)) {
-      const top = o[key];
-      const declaredSchema = fields[key];
+    for (const property of TypedObject.keys(item)) {
+      const top = item[property];
+      const declaredSchema = fields[property];
       const declaredType = declaredSchema.type;
-      const sPath = declaredType === String ?
-        ((key === 'id' && !path) ? '_id' : `${path}${key}`) :
-        `${path}${key}`;
+      const subPath = declaredType === String ?
+        ((property === 'id' && !path) ? '_id' : `${path}${property}`) :
+        `${path}${property}`;
 
-      const sPathQuery = (val: unknown): {} => (key === 'id' && !path) ?
-        { ids: { values: Array.isArray(val) ? val : [val] } } :
-        { [Array.isArray(val) ? 'terms' : 'term']: { [sPath]: val } };
+      const subPathQuery = (value: unknown): {} => (property === 'id' && !path) ?
+        { ids: { values: Array.isArray(value) ? value : [value] } } :
+        { [Array.isArray(value) ? 'terms' : 'term']: { [subPath]: value } };
 
       if (DataUtil.isPlainObject(top)) {
         const subKey = Object.keys(top)[0];
         if (!subKey.startsWith('$')) {
-          const inner = this.extractWhereTermQuery(declaredType, top, config, `${sPath}.`);
+          const inner = this.extractWhereTermQuery(declaredType, top, config, `${subPath}.`);
           items.push(declaredSchema.array ?
-            { nested: { path: sPath, query: inner } } :
+            { nested: { path: subPath, query: inner } } :
             inner
           );
         } else {
-          const v = top[subKey];
+          const value = top[subKey];
 
           switch (subKey) {
             case '$all': {
-              const arr = Array.isArray(v) ? v : [v];
+              const values = Array.isArray(value) ? value : [value];
               items.push({
                 bool: {
-                  must: arr.map(x => ({ term: { [sPath]: x } }))
+                  must: values.map(term => ({ term: { [subPath]: term } }))
                 }
               });
               break;
             }
             case '$in': {
-              items.push(sPathQuery(Array.isArray(v) ? v : [v]));
+              items.push(subPathQuery(Array.isArray(value) ? value : [value]));
               break;
             }
             case '$nin': {
-              items.push({ bool: { ['must_not']: [sPathQuery(Array.isArray(v) ? v : [v])] } });
+              items.push({ bool: { ['must_not']: [subPathQuery(Array.isArray(value) ? value : [value])] } });
               break;
             }
             case '$eq': {
-              items.push(sPathQuery(v));
+              items.push(subPathQuery(value));
               break;
             }
             case '$ne': {
-              items.push({ bool: { ['must_not']: [sPathQuery(v)] } });
+              items.push({ bool: { ['must_not']: [subPathQuery(value)] } });
               break;
             }
             case '$exists': {
-              const q = { exists: { field: sPath } };
-              items.push(v ? q : { bool: { ['must_not']: q } });
+              const clause = { exists: { field: subPath } };
+              items.push(value ? clause : { bool: { ['must_not']: clause } });
               break;
             }
             case '$lt':
@@ -126,18 +126,18 @@ export class ElasticsearchQueryUtil {
             case '$gte':
             case '$lte': {
               const out: Record<string, unknown> = {};
-              for (const k of Object.keys(top)) {
-                out[k.replace(/^[$]/, '')] = ModelQueryUtil.resolveComparator(top[k]);
+              for (const key of Object.keys(top)) {
+                out[key.replace(/^[$]/, '')] = ModelQueryUtil.resolveComparator(top[key]);
               }
-              items.push({ range: { [sPath]: out } });
+              items.push({ range: { [subPath]: out } });
               break;
             }
             case '$regex': {
-              const pattern = DataUtil.toRegex(castTo(v));
+              const pattern = DataUtil.toRegex(castTo(value));
               if (pattern.source.startsWith('\\b') && pattern.source.endsWith('.*')) {
                 const textField = !pattern.flags.includes('i') && config && config.caseSensitive ?
-                  `${sPath}.text_cs` :
-                  `${sPath}.text`;
+                  `${subPath}.text_cs` :
+                  `${subPath}.text`;
                 const query = pattern.source.substring(2, pattern.source.length - 2);
                 items.push({
                   ['match_phrase_prefix']: {
@@ -145,12 +145,12 @@ export class ElasticsearchQueryUtil {
                   }
                 });
               } else {
-                items.push({ regexp: { [sPath]: pattern.source } });
+                items.push({ regexp: { [subPath]: pattern.source } });
               }
               break;
             }
             case '$geoWithin': {
-              items.push({ ['geo_polygon']: { [sPath]: { points: v } } });
+              items.push({ ['geo_polygon']: { [subPath]: { points: value } } });
               break;
             }
             case '$unit':
@@ -165,7 +165,7 @@ export class ElasticsearchQueryUtil {
               items.push({
                 ['geo_distance']: {
                   distance: `${dist}${unit}`,
-                  [sPath]: top.$near
+                  [subPath]: top.$near
                 }
               });
               break;
@@ -174,7 +174,7 @@ export class ElasticsearchQueryUtil {
         }
         // Handle operations
       } else {
-        items.push(sPathQuery(top));
+        items.push(subPathQuery(top));
       }
     }
     if (items.length === 1) {
@@ -187,15 +187,15 @@ export class ElasticsearchQueryUtil {
   /**
    * Build query from the where clause
    */
-  static extractWhereQuery<T>(cls: Class<T>, o: WhereClause<T>, config?: EsSchemaConfig): Record<string, unknown> {
-    if (ModelQueryUtil.has$And(o)) {
-      return { bool: { must: o.$and.map(x => this.extractWhereQuery<T>(cls, x, config)) } };
-    } else if (ModelQueryUtil.has$Or(o)) {
-      return { bool: { should: o.$or.map(x => this.extractWhereQuery<T>(cls, x, config)), ['minimum_should_match']: 1 } };
-    } else if (ModelQueryUtil.has$Not(o)) {
-      return { bool: { ['must_not']: this.extractWhereQuery<T>(cls, o.$not, config) } };
+  static extractWhereQuery<T>(cls: Class<T>, clause: WhereClause<T>, config?: EsSchemaConfig): Record<string, unknown> {
+    if (ModelQueryUtil.has$And(clause)) {
+      return { bool: { must: clause.$and.map(item => this.extractWhereQuery<T>(cls, item, config)) } };
+    } else if (ModelQueryUtil.has$Or(clause)) {
+      return { bool: { should: clause.$or.map(item => this.extractWhereQuery<T>(cls, item, config)), ['minimum_should_match']: 1 } };
+    } else if (ModelQueryUtil.has$Not(clause)) {
+      return { bool: { ['must_not']: this.extractWhereQuery<T>(cls, clause.$not, config) } };
     } else {
-      return this.extractWhereTermQuery(cls, o, config);
+      return this.extractWhereTermQuery(cls, clause, config);
     }
   }
 

package/src/internal/schema.ts

@@ -5,7 +5,10 @@ import { Point, DataUtil, SchemaRegistryIndex } from '@travetto/schema';
 
 import { EsSchemaConfig } from './types.ts';
 
-const PointImpl = toConcrete<Point>();
+const PointConcrete = toConcrete<Point>();
+
+const isMappingType = (input: estypes.MappingProperty): input is estypes.MappingTypeMapping =>
+  (input.type === 'object' || input.type === 'nested') && 'properties' in input && !!input.properties;
 
 /**
  * Utils for ES Schema management
@@ -15,7 +18,7 @@ export class ElasticsearchSchemaUtil {
   /**
    * Build the update script for a given object
    */
-  static generateUpdateScript(o: Record<string, unknown>): estypes.Script {
+  static generateUpdateScript(item: Record<string, unknown>): estypes.Script {
     const out: estypes.Script = {
       lang: 'painless',
       source: `
@@ -32,21 +35,21 @@ export class ElasticsearchSchemaUtil {
   }
  }
 `,
-      params: { body: o },
+      params: { body: item },
     };
     return out;
   }
 
   /**
    * Generate replace script
-   * @param o
+   * @param item
    * @returns
    */
-  static generateReplaceScript(o: Record<string, unknown>): estypes.Script {
+  static generateReplaceScript(item: Record<string, unknown>): estypes.Script {
     return {
       lang: 'painless',
       source: 'ctx._source.clear(); ctx._source.putAll(params.body)',
-      params: { body: o }
+      params: { body: item }
     };
   }
 
@@ -64,65 +67,65 @@ export class ElasticsearchSchemaUtil {
    */
   static generateAllMapping(cls: Class, config?: EsSchemaConfig): estypes.MappingTypeMapping {
     const allTypes = SchemaRegistryIndex.getDiscriminatedClasses(cls);
-    return allTypes.reduce<estypes.MappingTypeMapping>((acc, schemaCls) => {
-      DataUtil.deepAssign(acc, this.generateSingleMapping(schemaCls, config));
-      return acc;
+    return allTypes.reduce<estypes.MappingTypeMapping>((mapping, schemaCls) => {
+      DataUtil.deepAssign(mapping, this.generateSingleMapping(schemaCls, config));
+      return mapping;
     }, { properties: {}, dynamic: false });
   }
 
   /**
    * Build a mapping for a given class
    */
-  static generateSingleMapping<T>(cls: Class<T>, config?: EsSchemaConfig): estypes.MappingTypeMapping {
+  static generateSingleMapping<T>(cls: Class<T>, esSchema?: EsSchemaConfig): estypes.MappingTypeMapping {
     const fields = SchemaRegistryIndex.get(cls).getFields();
 
-    const props: Record<string, estypes.MappingProperty> = {};
+    const properties: Record<string, estypes.MappingProperty> = {};
 
-    for (const [field, conf] of Object.entries(fields)) {
-      if (conf.type === PointImpl) {
-        props[field] = { type: 'geo_point' };
-      } else if (conf.type === Number) {
-        let prop: Record<string, unknown> = { type: 'integer' };
-        if (conf.precision) {
-          const [digits, decimals] = conf.precision;
+    for (const [field, config] of Object.entries(fields)) {
+      if (config.type === PointConcrete) {
+        properties[field] = { type: 'geo_point' };
+      } else if (config.type === Number) {
+        let property: Record<string, unknown> = { type: 'integer' };
+        if (config.precision) {
+          const [digits, decimals] = config.precision;
           if (decimals) {
             if ((decimals + digits) < 16) {
-              prop = { type: 'scaled_float', ['scaling_factor']: decimals };
+              property = { type: 'scaled_float', ['scaling_factor']: decimals };
             } else {
               if (digits < 6 && decimals < 9) {
-                prop = { type: 'half_float' };
+                property = { type: 'half_float' };
               } else if (digits > 20) {
-                prop = { type: 'double' };
+                property = { type: 'double' };
               } else {
-                prop = { type: 'float' };
+                property = { type: 'float' };
               }
             }
           } else if (digits) {
             if (digits <= 2) {
-              prop = { type: 'byte' };
+              property = { type: 'byte' };
             } else if (digits <= 4) {
-              prop = { type: 'short' };
+              property = { type: 'short' };
             } else if (digits <= 9) {
-              prop = { type: 'integer' };
+              property = { type: 'integer' };
             } else {
-              prop = { type: 'long' };
+              property = { type: 'long' };
             }
           }
         }
-        props[field] = prop;
-      } else if (conf.type === Date) {
-        props[field] = { type: 'date', format: 'date_optional_time' };
-      } else if (conf.type === Boolean) {
-        props[field] = { type: 'boolean' };
-      } else if (conf.type === String) {
+        properties[field] = property;
+      } else if (config.type === Date) {
+        properties[field] = { type: 'date', format: 'date_optional_time' };
+      } else if (config.type === Boolean) {
+        properties[field] = { type: 'boolean' };
+      } else if (config.type === String) {
         let text = {};
-        if (conf.specifiers?.includes('text')) {
+        if (config.specifiers?.includes('text')) {
           text = {
             fields: {
               text: { type: 'text' }
             }
           };
-          if (config && config.caseSensitive) {
+          if (esSchema && esSchema.caseSensitive) {
             DataUtil.deepAssign(text, {
               fields: {
                 ['text_cs']: { type: 'text', analyzer: 'whitespace' }
@@ -130,17 +133,44 @@ export class ElasticsearchSchemaUtil {
             });
           }
         }
-        props[field] = { type: 'keyword', ...text };
-      } else if (conf.type === Object) {
-        props[field] = { type: 'object', dynamic: true };
-      } else if (SchemaRegistryIndex.has(conf.type)) {
-        props[field] = {
-          type: conf.array ? 'nested' : 'object',
-          ...this.generateSingleMapping(conf.type, config)
+        properties[field] = { type: 'keyword', ...text };
+      } else if (config.type === Object) {
+        properties[field] = { type: 'object', dynamic: true };
+      } else if (SchemaRegistryIndex.has(config.type)) {
+        properties[field] = {
+          type: config.array ? 'nested' : 'object',
+          ...this.generateSingleMapping(config.type, esSchema)
         };
       }
     }
 
-    return { properties: props, dynamic: false };
+    return { properties, dynamic: false };
+  }
+
+  /**
+   * Gets list of all changed fields between two mappings
+   */
+  static getChangedFields(current: estypes.MappingTypeMapping, needed: estypes.MappingTypeMapping, prefix = ''): string[] {
+    const currentProperties = (current.properties ?? {});
+    const neededProperties = (needed.properties ?? {});
+    const allKeys = new Set([...Object.keys(currentProperties), ...Object.keys(neededProperties)]);
+    const changed: string[] = [];
+
+    for (const key of allKeys) {
+      const path = prefix ? `${prefix}.${key}` : key;
+      const currentProperty = currentProperties[key];
+      const neededProperty = neededProperties[key];
+
+      if (!currentProperty || !neededProperty || currentProperty.type !== neededProperty.type) {
+        changed.push(path);
+      } else if (isMappingType(currentProperty) || isMappingType(neededProperty)) {
+        changed.push(...this.getChangedFields(
+          'properties' in currentProperty ? currentProperty : { properties: {} },
+          'properties' in neededProperty ? neededProperty : { properties: {} },
+          path
+        ));
+      }
+    }
+    return changed;
   }
 }

package/src/service.ts

@@ -1,12 +1,12 @@
 import { Client, errors, estypes } from '@elastic/elasticsearch';
 
 import {
-  ModelCrudSupport, BulkOp, BulkResponse, ModelBulkSupport, ModelExpirySupport,
+  ModelCrudSupport, BulkOperation, BulkResponse, ModelBulkSupport, ModelExpirySupport,
   ModelIndexedSupport, ModelType, ModelStorageSupport, NotFoundError, ModelRegistryIndex, OptionalId,
   ModelCrudUtil, ModelIndexedUtil, ModelStorageUtil, ModelExpiryUtil, ModelBulkUtil,
 } from '@travetto/model';
 import { ShutdownManager, type DeepPartial, type Class, castTo, asFull, TypedObject, asConstructable } from '@travetto/runtime';
-import { SchemaChange, BindUtil } from '@travetto/schema';
+import { BindUtil } from '@travetto/schema';
 import { Injectable } from '@travetto/di';
 import {
   ModelQuery, ModelQueryCrudSupport, ModelQueryFacetSupport,
@@ -55,41 +55,41 @@ export class ElasticsearchModelService implements
         query
       });
       return result;
-    } catch (err) {
-      if (err instanceof errors.ResponseError && err.meta.body && typeof err.meta.body === 'object' && 'error' in err.meta.body) {
-        console.error(err.meta.body.error);
+    } catch (error) {
+      if (error instanceof errors.ResponseError && error.meta.body && typeof error.meta.body === 'object' && 'error' in error.meta.body) {
+        console.error(error.meta.body.error);
       }
-      throw err;
+      throw error;
     }
   }
 
-  preUpdate(o: { id: string }): string;
-  preUpdate(o: {}): undefined;
-  preUpdate(o: { id?: string }): string | undefined {
-    if ('id' in o && typeof o.id === 'string') {
-      const id = o.id;
+  preUpdate(item: { id: string }): string;
+  preUpdate(item: {}): undefined;
+  preUpdate(item: { id?: string }): string | undefined {
+    if ('id' in item && typeof item.id === 'string') {
+      const id = item.id;
       if (!this.config.storeId) {
-        delete o.id;
+        delete item.id;
       }
       return id;
     }
     return;
   }
 
-  postUpdate<T extends ModelType>(o: T, id?: string): T {
+  postUpdate<T extends ModelType>(item: T, id?: string): T {
     if (!this.config.storeId) {
-      o.id = id!;
+      item.id = id!;
     }
-    return o;
+    return item;
   }
 
   /**
    * Convert _id to id
    */
-  async postLoad<T extends ModelType>(cls: Class<T>, inp: estypes.SearchHit<T> | estypes.GetGetResult<T>): Promise<T> {
+  async postLoad<T extends ModelType>(cls: Class<T>, input: estypes.SearchHit<T> | estypes.GetGetResult<T>): Promise<T> {
     let item = {
-      ...(inp._id ? { id: inp._id } : {}),
-      ...inp._source!,
+      ...(input._id ? { id: input._id } : {}),
+      ...input._source!,
     };
 
     item = await ModelCrudUtil.load(cls, item);
@@ -115,17 +115,16 @@ export class ElasticsearchModelService implements
     await this.client.cluster.health({});
     this.manager = new IndexManager(this.config, this.client);
 
-    await ModelStorageUtil.registerModelChangeListener(this.manager);
+    await ModelStorageUtil.storageInitialization(this.manager);
     ShutdownManager.onGracefulShutdown(() => this.client.close());
     ModelExpiryUtil.registerCull(this);
   }
 
   createStorage(): Promise<void> { return this.manager.createStorage(); }
   deleteStorage(): Promise<void> { return this.manager.deleteStorage(); }
-  createModel(cls: Class): Promise<void> { return this.manager.createModel(cls); }
+  upsertModel(cls: Class): Promise<void> { return this.manager.upsertModel(cls); }
   exportModel(cls: Class): Promise<string> { return this.manager.exportModel(cls); }
   deleteModel(cls: Class): Promise<void> { return this.manager.deleteModel(cls); }
-  changeSchema(cls: Class, change: SchemaChange): Promise<void> { return this.manager.changeSchema(cls, change); }
   truncateModel(cls: Class): Promise<void> { return this.deleteByQuery(cls, {}).then(() => { }); }
 
   async get<T extends ModelType>(cls: Class<T>, id: string): Promise<T> {
@@ -149,17 +148,17 @@ export class ElasticsearchModelService implements
       if (result.result === 'not_found') {
         throw new NotFoundError(cls, id);
       }
-    } catch (err) {
-      if (err && err instanceof errors.ResponseError && err.body && err.body.result === 'not_found') {
+    } catch (error) {
+      if (error && error instanceof errors.ResponseError && error.body && error.body.result === 'not_found') {
         throw new NotFoundError(cls, id);
       }
-      throw err;
+      throw error;
     }
   }
 
-  async create<T extends ModelType>(cls: Class<T>, o: OptionalId<T>): Promise<T> {
+  async create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T> {
     try {
-      const clean = await ModelCrudUtil.preStore(cls, o, this);
+      const clean = await ModelCrudUtil.preStore(cls, item, this);
       const id = this.preUpdate(clean);
 
       await this.client.index({
@@ -170,18 +169,18 @@ export class ElasticsearchModelService implements
       });
 
       return this.postUpdate(clean, id);
-    } catch (err) {
-      console.error(err);
-      throw err;
+    } catch (error) {
+      console.error(error);
+      throw error;
     }
   }
 
-  async update<T extends ModelType>(cls: Class<T>, o: T): Promise<T> {
+  async update<T extends ModelType>(cls: Class<T>, item: T): Promise<T> {
     ModelCrudUtil.ensureNotSubType(cls);
 
-    o = await ModelCrudUtil.preStore(cls, o, this);
+    item = await ModelCrudUtil.preStore(cls, item, this);
 
-    const id = this.preUpdate(o);
+    const id = this.preUpdate(item);
 
     if (ModelRegistryIndex.getConfig(cls).expiresAt) {
       await this.get(cls, id);
@@ -192,16 +191,16 @@ export class ElasticsearchModelService implements
       id,
       op_type: 'index',
       refresh: true,
-      body: castTo<T & { id: never }>(o)
+      body: castTo<T & { id: never }>(item)
     });
 
-    return this.postUpdate(o, id);
+    return this.postUpdate(item, id);
   }
 
-  async upsert<T extends ModelType>(cls: Class<T>, o: OptionalId<T>): Promise<T> {
+  async upsert<T extends ModelType>(cls: Class<T>, input: OptionalId<T>): Promise<T> {
     ModelCrudUtil.ensureNotSubType(cls);
 
-    const item = await ModelCrudUtil.preStore(cls, o, this);
+    const item = await ModelCrudUtil.preStore(cls, input, this);
     const id = this.preUpdate(item);
 
     await this.client.update({
@@ -229,11 +228,11 @@ export class ElasticsearchModelService implements
         refresh: true,
         script,
       });
-    } catch (err) {
-      if (err instanceof Error && /document_missing_exception/.test(err.message)) {
+    } catch (error) {
+      if (error instanceof Error && /document_missing_exception/.test(error.message)) {
         throw new NotFoundError(cls, id);
       }
-      throw err;
+      throw error;
     }
 
     return this.get(cls, id);
@@ -247,12 +246,12 @@ export class ElasticsearchModelService implements
     });
 
     while (search.hits.hits.length > 0) {
-      for (const el of search.hits.hits) {
+      for (const hit of search.hits.hits) {
         try {
-          yield this.postLoad(cls, el);
-        } catch (err) {
-          if (!(err instanceof NotFoundError)) {
-            throw err;
+          yield this.postLoad(cls, hit);
+        } catch (error) {
+          if (!(error instanceof NotFoundError)) {
+            throw error;
           }
         }
         search = await this.client.scroll({
@@ -263,28 +262,30 @@ export class ElasticsearchModelService implements
     }
   }
 
-  async processBulk<T extends ModelType>(cls: Class<T>, operations: BulkOp<T>[]): Promise<BulkResponse<EsBulkError>> {
+  async processBulk<T extends ModelType>(cls: Class<T>, operations: BulkOperation<T>[]): Promise<BulkResponse<EsBulkError>> {
 
     await ModelBulkUtil.preStore(cls, operations, this);
 
-    const body = operations.reduce<(T | Partial<Record<'delete' | 'create' | 'index' | 'update', { _index: string, _id?: string }>> | { doc: T })[]>((acc, op) => {
-
-      const esIdent = this.manager.getIdentity(asConstructable<T>((op.upsert ?? op.delete ?? op.insert ?? op.update ?? { constructor: cls })).constructor);
-      const ident: { _index: string, _type?: unknown } = { _index: esIdent.index };
-
-      if (op.delete) {
-        acc.push({ delete: { ...ident, _id: op.delete.id } });
-      } else if (op.insert) {
-        const id = this.preUpdate(op.insert);
-        acc.push({ create: { ...ident, _id: id } }, castTo(op.insert));
-      } else if (op.upsert) {
-        const id = this.preUpdate(op.upsert);
-        acc.push({ index: { ...ident, _id: id } }, castTo(op.upsert));
-      } else if (op.update) {
-        const id = this.preUpdate(op.update);
-        acc.push({ update: { ...ident, _id: id } }, { doc: op.update });
+    type BulkDoc = Partial<Record<'delete' | 'create' | 'index' | 'update', { _index: string, _id?: string }>>;
+    const body = operations.reduce<(T | BulkDoc | { doc: T })[]>((toRun, operation) => {
+
+      const core = (operation.upsert ?? operation.delete ?? operation.insert ?? operation.update ?? { constructor: cls });
+      const { index } = this.manager.getIdentity(asConstructable<T>(core).constructor);
+      const identity: { _index: string, _type?: unknown } = { _index: index };
+
+      if (operation.delete) {
+        toRun.push({ delete: { ...identity, _id: operation.delete.id } });
+      } else if (operation.insert) {
+        const id = this.preUpdate(operation.insert);
+        toRun.push({ create: { ...identity, _id: id } }, castTo(operation.insert));
+      } else if (operation.upsert) {
+        const id = this.preUpdate(operation.upsert);
+        toRun.push({ index: { ...identity, _id: id } }, castTo(operation.upsert));
+      } else if (operation.update) {
+        const id = this.preUpdate(operation.update);
+        toRun.push({ update: { ...identity, _id: id } }, { doc: operation.update });
       }
-      return acc;
+      return toRun;
     }, []);
 
     const result = await this.client.bulk({
@@ -304,35 +305,35 @@ export class ElasticsearchModelService implements
       errors: []
     };
 
-    type Count = keyof typeof out['counts'];
+    type CountProperty = keyof typeof out['counts'];
 
     for (let i = 0; i < result.items.length; i++) {
       const item = result.items[i];
-      const [k] = TypedObject.keys(item);
-      const v = item[k]!;
-      if (v.error) {
+      const [key] = TypedObject.keys(item);
+      const responseItem = item[key]!;
+      if (responseItem.error) {
         out.errors.push({
-          reason: v.error!.reason!,
-          type: v.error!.type
+          reason: responseItem.error!.reason!,
+          type: responseItem.error!.type
         });
         out.counts.error += 1;
       } else {
-        let sk: Count;
-        switch (k) {
-          case 'create': sk = 'insert'; break;
-          case 'index': sk = operations[i].insert ? 'insert' : 'upsert'; break;
-          case 'delete': case 'update': sk = k; break;
+        let property: CountProperty;
+        switch (key) {
+          case 'create': property = 'insert'; break;
+          case 'index': property = operations[i].insert ? 'insert' : 'upsert'; break;
+          case 'delete': case 'update': property = key; break;
           default: {
-            throw new Error(`Unknown response key: ${k}`);
+            throw new Error(`Unknown response key: ${key}`);
           }
         }
 
-        if (v.result === 'created') {
-          out.insertedIds.set(i, v._id!);
-          (operations[i].insert ?? operations[i].upsert)!.id = v._id!;
+        if (responseItem.result === 'created') {
+          out.insertedIds.set(i, responseItem._id!);
+          (operations[i].insert ?? operations[i].upsert)!.id = responseItem._id!;
         }
 
-        out.counts[sk] += 1;
+        out.counts[property] += 1;
       }
     }
 
@@ -380,7 +381,7 @@ export class ElasticsearchModelService implements
   }
 
   async * listByIndex<T extends ModelType>(cls: Class<T>, idx: string, body?: DeepPartial<T>): AsyncIterable<T> {
-    const cfg = ModelRegistryIndex.getIndex(cls, idx, ['sorted', 'unsorted']);
+    const config = ModelRegistryIndex.getIndex(cls, idx, ['sorted', 'unsorted']);
     let search = await this.execSearch<T>(cls, {
       scroll: '2m',
       size: 100,
@@ -388,16 +389,16 @@ export class ElasticsearchModelService implements
         ElasticsearchQueryUtil.extractWhereTermQuery(cls,
           ModelIndexedUtil.projectIndex(cls, idx, body, { emptySortValue: { $exists: true } }))
       ),
-      sort: ElasticsearchQueryUtil.getSort(cfg.fields)
+      sort: ElasticsearchQueryUtil.getSort(config.fields)
     });
 
     while (search.hits.hits.length > 0) {
-      for (const el of search.hits.hits) {
+      for (const hit of search.hits.hits) {
         try {
-          yield this.postLoad(cls, el);
-        } catch (err) {
-          if (!(err instanceof NotFoundError)) {
-            throw err;
+          yield this.postLoad(cls, hit);
+        } catch (error) {
+          if (!(error instanceof NotFoundError)) {
+            throw error;
           }
         }
         search = await this.client.scroll({
@@ -412,14 +413,14 @@ export class ElasticsearchModelService implements
   async query<T extends ModelType>(cls: Class<T>, query: PageableModelQuery<T>): Promise<T[]> {
     await QueryVerifier.verify(cls, query);
 
-    const req = ElasticsearchQueryUtil.getSearchObject(cls, query, this.config.schemaConfig);
-    const results = await this.execSearch(cls, req);
+    const search = ElasticsearchQueryUtil.getSearchObject(cls, query, this.config.schemaConfig);
+    const results = await this.execSearch(cls, search);
     const shouldRemoveIds = query.select && 'id' in query.select && !query.select.id;
-    return Promise.all(results.hits.hits.map(m => this.postLoad(cls, m).then(v => {
+    return Promise.all(results.hits.hits.map(hit => this.postLoad(cls, hit).then(item => {
       if (shouldRemoveIds) {
-        delete castTo<OptionalId<T>>(v).id;
+        delete castTo<OptionalId<T>>(item).id;
       }
-      return v;
+      return item;
     })));
   }
 
@@ -431,8 +432,8 @@ export class ElasticsearchModelService implements
   async queryCount<T extends ModelType>(cls: Class<T>, query: Query<T>): Promise<number> {
     await QueryVerifier.verify(cls, query);
 
-    const req = ElasticsearchQueryUtil.getSearchObject(cls, { ...query, limit: 0 }, this.config.schemaConfig);
-    const result: number | { value: number } = (await this.execSearch(cls, req)).hits.total || { value: 0 };
+    const search = ElasticsearchQueryUtil.getSearchObject(cls, { ...query, limit: 0 }, this.config.schemaConfig);
+    const result: number | { value: number } = (await this.execSearch(cls, search)).hits.total || { value: 0 };
     return typeof result !== 'number' ? result.value : result;
   }
 
@@ -470,11 +471,11 @@ export class ElasticsearchModelService implements
       if (result.version_conflicts || result.updated === undefined || result.updated === 0) {
         throw new NotFoundError(cls, id);
       }
-    } catch (err) {
-      if (err instanceof errors.ResponseError && 'version_conflicts' in err.body) {
+    } catch (error) {
+      if (error instanceof errors.ResponseError && 'version_conflicts' in error.body) {
         throw new NotFoundError(cls, id);
       } else {
-        throw err;
+        throw error;
       }
     }
 
@@ -484,10 +485,10 @@ export class ElasticsearchModelService implements
   async deleteByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T> = {}): Promise<number> {
     await QueryVerifier.verify(cls, query);
 
-    const { sort: _, ...q } = ElasticsearchQueryUtil.getSearchObject(cls, query, this.config.schemaConfig, false);
+    const { sort: _, ...rest } = ElasticsearchQueryUtil.getSearchObject(cls, query, this.config.schemaConfig, false);
     const result = await this.client.deleteByQuery({
       ...this.manager.getIdentity(cls),
-      ...q,
+      ...rest,
       refresh: true,
     });
     return result.deleted ?? 0;
@@ -514,34 +515,34 @@ export class ElasticsearchModelService implements
   async suggest<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>): Promise<T[]> {
     await QueryVerifier.verify(cls, query);
 
-    const q = ModelQuerySuggestUtil.getSuggestQuery<T>(cls, field, prefix, query);
-    const search = ElasticsearchQueryUtil.getSearchObject(cls, q);
+    const resolvedQuery = ModelQuerySuggestUtil.getSuggestQuery<T>(cls, field, prefix, query);
+    const search = ElasticsearchQueryUtil.getSearchObject(cls, resolvedQuery);
     const result = await this.execSearch(cls, search);
-    const all = await Promise.all(result.hits.hits.map(x => this.postLoad(cls, x)));
-    return ModelQuerySuggestUtil.combineSuggestResults(cls, field, prefix, all, (x, v) => v, query && query.limit);
+    const all = await Promise.all(result.hits.hits.map(hit => this.postLoad(cls, hit)));
+    return ModelQuerySuggestUtil.combineSuggestResults(cls, field, prefix, all, (_, value) => value, query && query.limit);
   }
 
   async suggestValues<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>): Promise<string[]> {
     await QueryVerifier.verify(cls, query);
 
-    const q = ModelQuerySuggestUtil.getSuggestQuery<T>(cls, field, prefix, {
+    const resolvedQuery = ModelQuerySuggestUtil.getSuggestQuery<T>(cls, field, prefix, {
       select: castTo({ [field]: 1 }),
       ...query
     });
-    const search = ElasticsearchQueryUtil.getSearchObject(cls, q);
+    const search = ElasticsearchQueryUtil.getSearchObject(cls, resolvedQuery);
     const result = await this.execSearch(cls, search);
-    const all = await Promise.all(result.hits.hits.map(x => castTo<T>(({ [field]: field === 'id' ? x._id : x._source![field] }))));
-    return ModelQuerySuggestUtil.combineSuggestResults(cls, field, prefix, all, x => x, query && query.limit);
+    const all = await Promise.all(result.hits.hits.map(hit => castTo<T>(({ [field]: field === 'id' ? hit._id : hit._source![field] }))));
+    return ModelQuerySuggestUtil.combineSuggestResults(cls, field, prefix, all, item => item, query && query.limit);
   }
 
   // Facet
   async facet<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, query?: ModelQuery<T>): Promise<ModelQueryFacet[]> {
     await QueryVerifier.verify(cls, query);
 
-    const q = ElasticsearchQueryUtil.getSearchObject(cls, query ?? {}, this.config.schemaConfig);
+    const resolvedSearch = ElasticsearchQueryUtil.getSearchObject(cls, query ?? {}, this.config.schemaConfig);
 
     const search: estypes.SearchRequest = {
-      query: q.query ?? { ['match_all']: {} },
+      query: resolvedSearch.query ?? { ['match_all']: {} },
       aggs: { [field]: { terms: { field, size: 100 } } },
       size: 0
     };