@travetto/model-elasticsearch 2.1.3 → 2.2.0

package/README.md

@@ -8,9 +8,9 @@
 npm install @travetto/model-elasticsearch
 ```
 
-This module provides an [elasticsearch](https://elastic.co)-based implementation of the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.").  This source allows the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module to read, write and query against [elasticsearch](https://elastic.co). In development mode, [ElasticsearchModelService](https://github.com/travetto/travetto/tree/main/module/model-elasticsearch/src/service.ts#L40) will also modify the [elasticsearch](https://elastic.co) schema in real time to minimize impact to development.
+This module provides an [elasticsearch](https://elastic.co)-based implementation of the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.").  This source allows the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module to read, write and query against [elasticsearch](https://elastic.co). In development mode, [ElasticsearchModelService](https://github.com/travetto/travetto/tree/main/module/model-elasticsearch/src/service.ts#L42) will also modify the [elasticsearch](https://elastic.co) schema in real time to minimize impact to development.
 
-Supported featrues:
+Supported features:
    
    *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/service/crud.ts#L11)
    *  [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/service/bulk.ts#L23)
@@ -94,14 +94,14 @@ export class ElasticsearchModelConfig {
   };
 
   /**
-   * Frequency of culling for expirable content
+   * Frequency of culling for cullable content
    */
   cullRate?: number | TimeSpan;
 
   /**
    * Build final hosts
    */
-  postConstruct() {
+  postConstruct(): void {
     console.debug('Constructed', { config: this });
     this.hosts = this.hosts
       .map(x => x.includes(':') ? x : `${x}:${this.port}`)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/model-elasticsearch",
   "displayName": "Elasticsearch Model Source",
-  "version": "2.1.3",
+  "version": "2.2.0",
   "description": "Elasticsearch backing for the travetto model module, with real-time modeling support for Elasticsearch mappings.",
   "keywords": [
     "elasticsearch",
@@ -29,12 +29,12 @@
   },
   "dependencies": {
     "@elastic/elasticsearch": "^7.17.0",
-    "@travetto/config": "^2.1.3",
-    "@travetto/model": "^2.1.3",
-    "@travetto/model-query": "2.1.3"
+    "@travetto/config": "^2.2.0",
+    "@travetto/model": "^2.2.0",
+    "@travetto/model-query": "2.2.0"
   },
   "devDependencies": {
-    "@travetto/app": "^2.1.3"
+    "@travetto/app": "^2.2.0"
   },
   "publishConfig": {
     "access": "public"

package/src/config.ts

@@ -47,14 +47,14 @@ export class ElasticsearchModelConfig {
   };
 
   /**
-   * Frequency of culling for expirable content
+   * Frequency of culling for cullable content
    */
   cullRate?: number | TimeSpan;
 
   /**
    * Build final hosts
    */
-  postConstruct() {
+  postConstruct(): void {
     console.debug('Constructed', { config: this });
     this.hosts = this.hosts
       .map(x => x.includes(':') ? x : `${x}:${this.port}`)

package/src/index-manager.ts

@@ -24,7 +24,7 @@ export class IndexManager implements ModelStorageSupport {
     this.#client = client;
   }
 
-  getStore(cls: Class) {
+  getStore(cls: Class): string {
     return ModelRegistry.getStore(cls).toLowerCase().replace(/[^A-Za-z0-9_]+/g, '_');
   }
 
@@ -32,7 +32,7 @@ export class IndexManager implements ModelStorageSupport {
    * Get namespaced index
    * @param idx
    */
-  getNamespacedIndex(idx: string) {
+  getNamespacedIndex(idx: string): string {
     if (this.config.namespace) {
       return `${this.config.namespace}_${idx}`;
     } else {
@@ -55,8 +55,9 @@ export class IndexManager implements ModelStorageSupport {
   /**
    * Build alias mappings from the current state in the database
    */
-  async computeAliasMappings(force = false) {
+  async computeAliasMappings(force = false): Promise<void> {
     if (force || !this.#indexToAlias.size) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const { body: aliases } = (await this.#client.cat.aliases({
         format: 'json'
       })) as { body: { index: string, alias: string }[] };
@@ -75,7 +76,7 @@ export class IndexManager implements ModelStorageSupport {
    * @param cls
    * @param alias
    */
-  async createIndex(cls: Class, alias = true) {
+  async createIndex(cls: Class, alias = true): Promise<string> {
     const schema = ElasticsearchSchemaUtil.generateSourceSchema(cls, this.config.schemaConfig);
     const ident = this.getIdentity(cls); // Already namespaced
     const concreteIndex = `${ident.index}_${Date.now()}`;
@@ -93,8 +94,8 @@ export class IndexManager implements ModelStorageSupport {
         mappings: ElasticsearchSchemaUtil.MAJOR_VER < 7 ? { [ident.type!]: schema } : schema,
         settings: this.config.indexCreate
       });
-    } catch (e) {
-      console.warn('Index already created', { index: ident.index, error: e });
+    } catch (err) {
+      console.warn('Index already created', { index: ident.index, error: err });
     }
     return concreteIndex;
   }
@@ -102,23 +103,23 @@ export class IndexManager implements ModelStorageSupport {
   /**
    * Build an index if missing
    */
-  async createIndexIfMissing(cls: Class) {
+  async createIndexIfMissing(cls: Class): Promise<void> {
     cls = ModelRegistry.getBaseModel(cls);
     const ident = this.getIdentity(cls);
     try {
       await this.#client.search(ident);
       console.debug('Index already exists, not creating', ident);
-    } catch (err) {
+    } catch {
       await this.createIndex(cls);
     }
   }
 
-  async createModel(cls: Class<ModelType>) {
+  async createModel(cls: Class<ModelType>): Promise<void> {
     await this.createIndexIfMissing(cls);
     await this.computeAliasMappings(true);
   }
 
-  async exportModel(cls: Class<ModelType>) {
+  async exportModel(cls: Class<ModelType>): Promise<string> {
     const schema = ElasticsearchSchemaUtil.generateSourceSchema(cls, this.config.schemaConfig);
     const ident = this.getIdentity(cls); // Already namespaced
     return `curl -XPOST $ES_HOST/${ident.index} -d '${JSON.stringify({
@@ -127,7 +128,7 @@ export class IndexManager implements ModelStorageSupport {
     })}'`;
   }
 
-  async deleteModel(cls: Class<ModelType>) {
+  async deleteModel(cls: Class<ModelType>): Promise<void> {
     const alias = this.getNamespacedIndex(this.getStore(cls));
     if (this.#aliasToIndex.get(alias)) {
       await this.#client.indices.delete({
@@ -140,23 +141,23 @@ export class IndexManager implements ModelStorageSupport {
   /**
    * When the schema changes
    */
-  async changeSchema(cls: Class, change: SchemaChange) {
+  async changeSchema(cls: Class, change: SchemaChange): Promise<void> {
     // Find which fields are gone
-    const removes = change.subs.reduce((acc, v) => {
+    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;
-    }, [] as string[]);
+    }, []);
 
     // Find which types have changed
-    const fieldChanges = change.subs.reduce((acc, v) => {
+    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;
-    }, [] as string[]);
+    }, []);
 
     const { index, type } = this.getIdentity(cls);
 
@@ -169,8 +170,7 @@ export class IndexManager implements ModelStorageSupport {
 
       const allChange = removes.concat(fieldChanges);
 
-      // Reindex
-      await this.#client.reindex({
+      const reindexBody: Reindex = {
         body: {
           source: { index: curr },
           dest: { index: next },
@@ -179,8 +179,11 @@ export class IndexManager implements ModelStorageSupport {
             source: allChange.map(x => `ctx._source.remove("${x}");`).join(' ') // Removing
           }
         },
-        waitForCompletion: true
-      } as Reindex);
+        wait_for_completion: true
+      };
+
+      // Reindex
+      await this.#client.reindex(reindexBody);
 
       await Promise.all(Object.keys(aliases)
         .map(x => this.#client.indices.delete({ index: x })));
@@ -197,13 +200,13 @@ export class IndexManager implements ModelStorageSupport {
     }
   }
 
-  async createStorage() {
-    // PreCreate indexes if missing
+  async createStorage(): Promise<void> {
+    // Pre-create indexes if missing
     console.debug('Create Storage', { idx: this.getNamespacedIndex('*') });
     await this.computeAliasMappings(true);
   }
 
-  async deleteStorage() {
+  async deleteStorage(): Promise<void> {
     console.debug('Deleting storage', { idx: this.getNamespacedIndex('*') });
     await this.#client.indices.delete({
       index: this.getNamespacedIndex('*')

package/src/internal/query.ts

@@ -13,8 +13,11 @@ import { SchemaRegistry } from '@travetto/schema';
 import { SearchResponse } from '../types';
 import { EsSchemaConfig } from './types';
 
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
 const has$And = (o: unknown): o is ({ $and: WhereClause<unknown>[] }) => !!o && '$and' in (o as object);
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
 const has$Or = (o: unknown): o is ({ $or: WhereClause<unknown>[] }) => !!o && '$or' in (o as object);
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
 const has$Not = (o: unknown): o is ({ $not: WhereClause<unknown> }) => !!o && '$not' in (o as object);
 
 /**
@@ -27,10 +30,12 @@ export class ElasticsearchQueryUtil {
    */
   static extractSimple<T>(o: T, path: string = ''): Record<string, unknown> {
     const out: Record<string, unknown> = {};
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const sub = o as Record<string, unknown>;
     const keys = Object.keys(sub);
     for (const key of keys) {
       const subPath = `${path}${key}`;
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       if (Util.isPlainObject(sub[key]) && !Object.keys(sub[key] as object)[0].startsWith('$')) {
         Object.assign(out, this.extractSimple(sub[key], `${subPath}.`));
       } else {
@@ -43,12 +48,13 @@ export class ElasticsearchQueryUtil {
   /**
    * Build include/exclude from the select clause
    */
-  static getSelect<T>(clause: SelectClause<T>) {
+  static getSelect<T>(clause: SelectClause<T>): [string[], string[]] {
     const simp = this.extractSimple(clause);
     const include: string[] = [];
     const exclude: string[] = [];
     for (const k of Object.keys(simp)) {
       const nk = k === 'id' ? '_id' : k;
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const v = simp[k] as (1 | 0 | boolean);
       if (v === 0 || v === false) {
         exclude.push(nk);
@@ -62,10 +68,11 @@ export class ElasticsearchQueryUtil {
   /**
    * Build sort mechanism
    */
-  static getSort<T extends ModelType>(sort: SortClause<T>[] | IndexConfig<T>['fields']) {
+  static getSort<T extends ModelType>(sort: SortClause<T>[] | IndexConfig<T>['fields']): string[] {
     return sort.map(x => {
       const o = this.extractSimple(x);
       const k = Object.keys(o)[0];
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const v = o[k] as (boolean | -1 | 1);
       if (v === 1 || v === true) {
         return k;
@@ -82,6 +89,7 @@ export class ElasticsearchQueryUtil {
     const items = [];
     const schema = SchemaRegistry.getViewSchema(cls).schema;
 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     for (const key of Object.keys(o) as (keyof typeof o)[]) {
       const top = o[key];
       const declaredSchema = schema[key];
@@ -154,6 +162,7 @@ export class ElasticsearchQueryUtil {
               break;
             }
             case '$regex': {
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
               const pattern = Util.toRegex(v as string);
               if (pattern.source.startsWith('\\b') && pattern.source.endsWith('.*')) {
                 const textField = !pattern.flags.includes('i') && config && config.caseSensitive ?
@@ -180,6 +189,7 @@ export class ElasticsearchQueryUtil {
               let dist = top.$maxDistance;
               let unit = top.$unit ?? 'm';
               if (unit === 'rad') {
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
                 dist = 6378.1 * (dist as number);
                 unit = 'km';
               }
@@ -229,7 +239,7 @@ export class ElasticsearchQueryUtil {
    * @param cls
    * @param search
    */
-  static getSearchBody<T extends ModelType>(cls: Class<T>, search: Record<string, unknown>, checkExpiry = true) {
+  static getSearchBody<T extends ModelType>(cls: Class<T>, search: Record<string, unknown>, checkExpiry = true): { query?: Record<string, unknown> } {
     const clauses = [];
     if (search && Object.keys(search).length) {
       clauses.push(search);
@@ -264,6 +274,7 @@ export class ElasticsearchQueryUtil {
     QueryVerifier.verify(cls, query); // Verify
 
     const search: Search = {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       body: this.getSearchBody(cls, this.extractWhereQuery(cls, query.where as WhereClause<T>, config), checkExpiry)
     };
 
@@ -301,7 +312,7 @@ export class ElasticsearchQueryUtil {
   static cleanIdRemoval<T>(req: Search, results: SearchResponse<T>): T[] {
     const out: T[] = [];
 
-    const toArr = <V>(x: V | V[] | undefined) => (x ? (Array.isArray(x) ? x : [x]) : []);
+    const toArr = <V>(x: V | V[] | undefined): V[] => (x ? (Array.isArray(x) ? x : [x]) : []);
 
     // determine if id
     const select = [

package/src/internal/schema.ts

@@ -22,6 +22,12 @@ type SchemaType = {
   dynamic: boolean;
 };
 
+type UpdateScript = {
+  params: Record<string, unknown>;
+  lang: 'painless';
+  source: string;
+};
+
 /**
  * Utils for ES Schema management
  */
@@ -32,10 +38,10 @@ export class ElasticsearchSchemaUtil {
   /**
    * Build the update script for a given object
    */
-  static generateUpdateScript(o: Record<string, unknown>, path: string = '', arr = false) {
+  static generateUpdateScript(o: Record<string, unknown>, path: string = '', arr = false): UpdateScript {
     const ops: string[] = [];
-    const out = {
-      params: {} as Record<string, unknown>,
+    const out: UpdateScript = {
+      params: {},
       lang: 'painless',
       source: ''
     };
@@ -52,6 +58,7 @@ export class ElasticsearchSchemaUtil {
         out.params[param] = o[x];
       } else {
         ops.push(`ctx._source.${prop} = ctx._source.${prop} == null ? [:] : ctx._source.${prop}`);
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const sub = this.generateUpdateScript(o[x] as Record<string, unknown>, prop);
         ops.push(sub.source);
         Object.assign(out.params, sub.params);
@@ -65,7 +72,7 @@ export class ElasticsearchSchemaUtil {
   /**
    * Build one or more schemas depending on the polymorphic state
    */
-  static generateSourceSchema(cls: Class, config?: EsSchemaConfig) {
+  static generateSourceSchema(cls: Class, config?: EsSchemaConfig): SchemaType {
     return ModelRegistry.get(cls).baseType ?
       this.generateAllSourceSchema(cls, config) :
       this.generateSingleSourceSchema(cls, config);
@@ -74,12 +81,12 @@ export class ElasticsearchSchemaUtil {
   /**
    * Generate all schemas
    */
-  static generateAllSourceSchema(cls: Class, config?: EsSchemaConfig) {
+  static generateAllSourceSchema(cls: Class, config?: EsSchemaConfig): SchemaType {
     const allTypes = ModelRegistry.getClassesByBaseType(cls);
-    return allTypes.reduce((acc, scls) => {
-      Util.deepAssign(acc, this.generateSingleSourceSchema(scls, config));
+    return allTypes.reduce<SchemaType>((acc, schemaCls) => {
+      Util.deepAssign(acc, this.generateSingleSourceSchema(schemaCls, config));
       return acc;
-    }, {} as SchemaType);
+    }, { properties: {}, dynamic: false });
   }
 
   /**

package/src/service.ts

@@ -1,5 +1,5 @@
 import * as es from '@elastic/elasticsearch';
-import { Index, Update, Search, DeleteByQuery } from '@elastic/elasticsearch/api/requestParams';
+import { Search } from '@elastic/elasticsearch/api/requestParams';
 
 import {
   ModelCrudSupport, BulkOp, BulkResponse, ModelBulkSupport, ModelExpirySupport,
@@ -25,7 +25,7 @@ import { ModelQuerySuggestSupport } from '@travetto/model-query/src/service/sugg
 import { ModelBulkUtil } from '@travetto/model/src/internal/service/bulk';
 
 import { ElasticsearchModelConfig } from './config';
-import { EsIdentity, EsBulkError } from './internal/types';
+import { EsBulkError } from './internal/types';
 import { ElasticsearchQueryUtil } from './internal/query';
 import { ElasticsearchSchemaUtil } from './internal/schema';
 import { IndexManager } from './index-manager';
@@ -33,6 +33,8 @@ import { SearchResponse } from './types';
 
 type WithId<T> = T & { _id?: string };
 
+const isWithId = <T extends ModelType>(o: T): o is WithId<T> => !o && '_id' in o;
+
 /**
  * Elasticsearch model source.
  */
@@ -55,18 +57,20 @@ export class ElasticsearchModelService implements
   async execSearch<T extends ModelType>(cls: Class<T>, search: Search<unknown>): Promise<SearchResponse<T>> {
     const res = await this.client.search({
       ...this.manager.getIdentity(cls),
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       ...search as Search<T>
     });
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return res as unknown as SearchResponse<T>;
   }
 
   /**
    * Convert _id to id
    */
-  async postLoad<T extends ModelType>(cls: Class<T>, o: T) {
-    if ('_id' in o) {
-      (o as { id?: unknown }).id = (o as WithId<T>)._id;
-      delete (o as WithId<T>)._id;
+  async postLoad<T extends ModelType>(cls: Class<T>, o: T): Promise<T> {
+    if (isWithId(o)) {
+      o.id = o._id!;
+      delete o._id;
     }
 
     o = await ModelCrudUtil.load(cls, o);
@@ -84,7 +88,7 @@ export class ElasticsearchModelService implements
     }
   }
 
-  async postConstruct(this: ElasticsearchModelService) {
+  async postConstruct(this: ElasticsearchModelService): Promise<void> {
     this.client = new es.Client({
       nodes: this.config.hosts,
       ...(this.config.options || {})
@@ -92,38 +96,39 @@ export class ElasticsearchModelService implements
     await this.client.cluster.health({});
     this.manager = new IndexManager(this.config, this.client);
 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     await ModelStorageUtil.registerModelChangeListener(this.manager, this.constructor as Class);
     ShutdownManager.onShutdown(this.constructor.ᚕid, () => this.client.close());
     ModelExpiryUtil.registerCull(this);
   }
 
-  createStorage() { return this.manager.createStorage(); }
-  deleteStorage() { return this.manager.deleteStorage(); }
-  createModel(cls: Class) { return this.manager.createModel(cls); }
-  exportModel(cls: Class) { return this.manager.exportModel(cls); }
-  deleteModel(cls: Class) { return this.manager.deleteModel(cls); }
-  changeSchema(cls: Class, change: SchemaChange) { return this.manager.changeSchema(cls, change); }
-  truncateModel(cls: Class) { return this.deleteByQuery(cls, {}).then(() => { }); }
+  createStorage(): Promise<void> { return this.manager.createStorage(); }
+  deleteStorage(): Promise<void> { return this.manager.deleteStorage(); }
+  createModel(cls: Class): Promise<void> { return this.manager.createModel(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(() => { }); }
 
-  uuid() {
+  uuid(): string {
     return Util.uuid();
   }
 
-  async get<T extends ModelType>(cls: Class<T>, id: string) {
+  async get<T extends ModelType>(cls: Class<T>, id: string): Promise<T> {
     try {
       const res = await this.client.get({ ...this.manager.getIdentity(cls), id });
       return this.postLoad(cls, res.body._source);
-    } catch (err) {
+    } catch {
       throw new NotFoundError(cls, id);
     }
   }
 
-  async delete<T extends ModelType>(cls: Class<T>, id: string) {
+  async delete<T extends ModelType>(cls: Class<T>, id: string): Promise<void> {
     ModelCrudUtil.ensureNotSubType(cls);
 
     try {
       const { body: res } = await this.client.delete({
-        ...this.manager.getIdentity(cls) as Required<EsIdentity>,
+        ...this.manager.getIdentity(cls),
         id,
         refresh: true
       });
@@ -131,7 +136,7 @@ export class ElasticsearchModelService implements
         throw new NotFoundError(cls, id);
       }
     } catch (err) {
-      if (err.body && err.body.result === 'not_found') {
+      if (err && err instanceof es.errors.ResponseError && err.body && err.body.result === 'not_found') {
         throw new NotFoundError(cls, id);
       }
       throw err;
@@ -144,7 +149,7 @@ export class ElasticsearchModelService implements
       const id = clean.id;
 
       await this.client.index({
-        ...this.manager.getIdentity(cls) as Required<EsIdentity>,
+        ...this.manager.getIdentity(cls),
         id,
         refresh: true,
         body: clean
@@ -171,16 +176,16 @@ export class ElasticsearchModelService implements
     await this.client.index({
       ...this.manager.getIdentity(cls),
       id,
-      opType: 'index',
+      op_type: 'index',
       refresh: true,
       body: o
-    } as Index);
+    });
 
     o.id = id;
     return o;
   }
 
-  async upsert<T extends ModelType>(cls: Class<T>, o: OptionalId<T>) {
+  async upsert<T extends ModelType>(cls: Class<T>, o: OptionalId<T>): Promise<T> {
     ModelCrudUtil.ensureNotSubType(cls);
 
     const item = await ModelCrudUtil.preStore(cls, o, this);
@@ -198,7 +203,7 @@ export class ElasticsearchModelService implements
     return item;
   }
 
-  async updatePartial<T extends ModelType>(cls: Class<T>, data: Partial<T> & { id: string }) {
+  async updatePartial<T extends ModelType>(cls: Class<T>, data: Partial<T> & { id: string }): Promise<T> {
     ModelCrudUtil.ensureNotSubType(cls);
 
     const script = ElasticsearchSchemaUtil.generateUpdateScript(data);
@@ -213,12 +218,12 @@ export class ElasticsearchModelService implements
       body: {
         script
       }
-    } as Update);
+    });
 
     return this.get(cls, id);
   }
 
-  async * list<T extends ModelType>(cls: Class<T>) {
+  async * list<T extends ModelType>(cls: Class<T>): AsyncIterable<T> {
     let search: SearchResponse<T> = await this.execSearch(cls, {
       scroll: '2m',
       size: 100,
@@ -242,38 +247,42 @@ export class ElasticsearchModelService implements
     }
   }
 
-  async processBulk<T extends ModelType>(cls: Class<T>, operations: BulkOp<T>[]) {
+  async processBulk<T extends ModelType>(cls: Class<T>, operations: BulkOp<T>[]): Promise<BulkResponse<EsBulkError>> {
 
     await ModelBulkUtil.preStore(cls, operations, this);
 
-    const body = operations.reduce((acc, op) => {
+    const body = operations.reduce<(T | Partial<Record<'delete' | 'create' | 'index' | 'update', { _index: string, _id?: string }>> | { doc: T })[]>((acc, op) => {
 
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const esIdent = this.manager.getIdentity((op.upsert ?? op.delete ?? op.insert ?? op.update ?? { constructor: cls }).constructor as Class);
-      const ident = (ElasticsearchSchemaUtil.MAJOR_VER < 7 ?
+      const ident: { _index: string, _type?: unknown } = (ElasticsearchSchemaUtil.MAJOR_VER < 7 ?
         { _index: esIdent.index, _type: esIdent.type } :
-        { _index: esIdent.index }) as { _index: string };
+        { _index: esIdent.index });
 
       if (op.delete) {
         acc.push({ delete: { ...ident, _id: op.delete.id } });
       } else if (op.insert) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         acc.push({ create: { ...ident, _id: op.insert.id } }, op.insert as T);
-        delete (op.insert as { id?: unknown }).id;
+        delete op.insert.id;
       } else if (op.upsert) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         acc.push({ index: { ...ident, _id: op.upsert.id } }, op.upsert as T);
-        delete (op.upsert as { id?: unknown }).id;
+        delete op.upsert.id;
       } else if (op.update) {
         acc.push({ update: { ...ident, _id: op.update.id } }, { doc: op.update });
-        delete (op.update as { id?: unknown }).id;
+        // @ts-expect-error
+        delete op.update.id;
       }
       return acc;
-    }, [] as (T | Partial<Record<'delete' | 'create' | 'index' | 'update', { _index: string, _id?: string }>> | { doc: T })[]);
+    }, []);
 
     const { body: res } = await this.client.bulk({
       body,
       refresh: true
     });
 
-    const out: BulkResponse = {
+    const out: BulkResponse<EsBulkError> = {
       counts: {
         delete: 0,
         insert: 0,
@@ -282,14 +291,14 @@ export class ElasticsearchModelService implements
         error: 0
       },
       insertedIds: new Map(),
-      errors: [] as EsBulkError[]
+      errors: []
     };
 
     type Count = keyof typeof out['counts'];
 
     for (let i = 0; i < res.items.length; i++) {
       const item = res.items[i];
-      const [k] = Object.keys(item) as (Count | 'create' | 'index')[];
+      const [k] = Util.getKeys<Count | 'create' | 'index'>(item);
       const v = item[k]!;
       if (v.error) {
         out.errors.push(v.error);
@@ -317,12 +326,12 @@ export class ElasticsearchModelService implements
   }
 
   // Expiry
-  deleteExpired<T extends ModelType>(cls: Class<T>) {
+  deleteExpired<T extends ModelType>(cls: Class<T>): Promise<number> {
     return ModelQueryExpiryUtil.deleteExpired(this, cls);
   }
 
   // Indexed
-  async getByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>) {
+  async getByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<T> {
     const { key } = ModelIndexedUtil.computeIndexKey(cls, idx, body);
     const res: SearchResponse<T> = await this.execSearch(cls, {
       body: ElasticsearchQueryUtil.getSearchBody(cls,
@@ -336,7 +345,7 @@ export class ElasticsearchModelService implements
     return this.postLoad(cls, res.body.hits.hits[0]._source);
   }
 
-  async deleteByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>) {
+  async deleteByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<void> {
     const { key } = ModelIndexedUtil.computeIndexKey(cls, idx, body);
     const res = await this.client.deleteByQuery({
       index: this.manager.getIdentity(cls).index,
@@ -356,7 +365,7 @@ export class ElasticsearchModelService implements
     return ModelIndexedUtil.naiveUpsert(this, cls, idx, body);
   }
 
-  async * listByIndex<T extends ModelType>(cls: Class<T>, idx: string, body?: DeepPartial<T>) {
+  async * listByIndex<T extends ModelType>(cls: Class<T>, idx: string, body?: DeepPartial<T>): AsyncIterable<T> {
     const cfg = ModelRegistry.getIndex(cls, idx);
     if (cfg.type === 'unique') {
       throw new AppError('Cannot list on unique indices', 'data');
@@ -402,17 +411,19 @@ export class ElasticsearchModelService implements
 
   async queryCount<T extends ModelType>(cls: Class<T>, query: Query<T>): Promise<number> {
     const req = ElasticsearchQueryUtil.getSearchObject(cls, { ...query, limit: 0 }, this.config.schemaConfig);
-    const res = (await this.execSearch(cls, req)).body.hits.total as (number | { value: number } | undefined);
-    return res ? typeof res === 'number' ? res : res.value : 0;
+    const res: number | { value: number } = (await this.execSearch(cls, req)).body.hits.total || { value: 0 };
+    return typeof res !== 'number' ? res.value : res;
   }
 
   // Query Crud
   async deleteByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T> = {}): Promise<number> {
     const { body: res } = await this.client.deleteByQuery({
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      body: undefined as unknown as {},
       ...this.manager.getIdentity(cls),
       refresh: true,
       ...ElasticsearchQueryUtil.getSearchObject(cls, query, this.config.schemaConfig, false)
-    } as DeleteByQuery);
+    });
     return res.deleted ?? 0;
   }
 
@@ -425,6 +436,7 @@ export class ElasticsearchModelService implements
       ...this.manager.getIdentity(cls),
       refresh: true,
       body: {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         query: (search.body as Record<string, unknown>).query,
         script
       }
@@ -461,6 +473,7 @@ export class ElasticsearchModelService implements
 
     const search = {
       body: {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         query: (q.body as Record<string, unknown>).query ?? { ['match_all']: {} },
         aggs: { [field]: { terms: { field, size: 100 } } }
       },
@@ -468,7 +481,7 @@ export class ElasticsearchModelService implements
     };
 
     const res = await this.execSearch(cls, search);
-    const { buckets } = res.body.aggregations[field as string];
+    const { buckets } = res.body.aggregations[field];
     const out = buckets.map(b => ({ key: b.key, count: b.doc_count }));
     return out;
   }