@travetto/model-mongo 2.1.5 → 2.2.2

package/README.md

@@ -10,10 +10,10 @@ npm install @travetto/model-mongo
 
 This module provides an [mongodb](https://mongodb.com)-based implementation for 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 [mongodb](https://mongodb.com).. Given the dynamic nature of [mongodb](https://mongodb.com), during development when models are modified, nothing needs to be done to adapt to the latest schema.
 
-Supported featrues:
+Supported features:
    
    *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/service/crud.ts#L11)
-   *  [Streaming](https://github.com/travetto/travetto/tree/main/module/model/src/service/stream.ts#L1)
+   *  [Streaming](https://github.com/travetto/travetto/tree/main/module/model/src/service/stream.ts#L3)
    *  [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/service/expiry.ts#L11)
    *  [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/service/bulk.ts#L23)
    *  [Indexed](https://github.com/travetto/travetto/tree/main/module/model/src/service/indexed.ts#L12)
@@ -95,22 +95,22 @@ export class MongoModelConfig {
   };
 
   /**
-   * Should we autocreate the db
+   * Should we auto create the db
    */
   autoCreate?: boolean;
 
   /**
-   * Frequency of culling for expirable content
+   * Frequency of culling for cullable content
    */
   cullRate?: number | TimeSpan;
 
   /**
    * Load a resource
    */
-  async fetch(val: string) {
+  async fetch(val: string): Promise<string> {
     return ResourceManager.read(val)
       .then(res => typeof res === 'string' ? res : res.toString('utf8'))
-      .catch(e => fs.readFile(val)
+      .catch(() => fs.readFile(val)
         .then(res => typeof res === 'string' ? res : res.toString('utf8'))
       )
       .catch(() => val);
@@ -119,7 +119,7 @@ export class MongoModelConfig {
   /**
    * Load all the ssl certs as needed
    */
-  async postConstruct() {
+  async postConstruct(): Promise<void> {
     const opts = this.options;
     if (opts.ssl) {
       if (opts.sslCert) {
@@ -140,7 +140,7 @@ export class MongoModelConfig {
   /**
    * Build connection URLs
    */
-  get url() {
+  get url(): string {
     const hosts = this.hosts
       .map(h => (this.srvRecord || h.includes(':')) ? h : `${h}:${this.port}`)
       .join(',');
@@ -159,4 +159,4 @@ export class MongoModelConfig {
   standard [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Environment-aware config management using yaml files")resolution paths. 
   
 
-The SSL file options in `clientOptions` will automatically be resolved to files when given a path.  This path can be a [ResourceManager](https://github.com/travetto/travetto/tree/main/module/base/src/resource.ts#L14) path or just a standard file path.
+The SSL file options in `clientOptions` will automatically be resolved to files when given a path.  This path can be a [ResourceManager](https://github.com/travetto/travetto/tree/main/module/base/src/resource.ts#L16) path or just a standard file path.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/model-mongo",
   "displayName": "MongoDB Model Support",
-  "version": "2.1.5",
+  "version": "2.2.2",
   "description": "Mongo backing for the travetto model module.",
   "keywords": [
     "mongo",
@@ -26,9 +26,9 @@
     "directory": "module/model-mongo"
   },
   "dependencies": {
-    "@travetto/config": "^2.1.5",
-    "@travetto/model": "^2.1.5",
-    "@travetto/model-query": "2.1.5",
+    "@travetto/config": "^2.2.2",
+    "@travetto/model": "^2.2.2",
+    "@travetto/model-query": "2.2.2",
     "mongodb": "^4.8.0"
   },
   "publishConfig": {

package/src/config.ts

@@ -47,22 +47,22 @@ export class MongoModelConfig {
   };
 
   /**
-   * Should we autocreate the db
+   * Should we auto create the db
    */
   autoCreate?: boolean;
 
   /**
-   * Frequency of culling for expirable content
+   * Frequency of culling for cullable content
    */
   cullRate?: number | TimeSpan;
 
   /**
    * Load a resource
    */
-  async fetch(val: string) {
+  async fetch(val: string): Promise<string> {
     return ResourceManager.read(val)
       .then(res => typeof res === 'string' ? res : res.toString('utf8'))
-      .catch(e => fs.readFile(val)
+      .catch(() => fs.readFile(val)
         .then(res => typeof res === 'string' ? res : res.toString('utf8'))
       )
       .catch(() => val);
@@ -71,7 +71,7 @@ export class MongoModelConfig {
   /**
    * Load all the ssl certs as needed
    */
-  async postConstruct() {
+  async postConstruct(): Promise<void> {
     const opts = this.options;
     if (opts.ssl) {
       if (opts.sslCert) {
@@ -92,7 +92,7 @@ export class MongoModelConfig {
   /**
    * Build connection URLs
    */
-  get url() {
+  get url(): string {
     const hosts = this.hosts
       .map(h => (this.srvRecord || h.includes(':')) ? h : `${h}:${this.port}`)
       .join(',');

package/src/internal/util.ts

@@ -17,29 +17,35 @@ const RADIANS_TO: Record<DistanceUnit, number> = {
   rad: 1
 };
 
-export type WithId<T> = T & { _id: mongo.Binary };
+export type WithId<T> = T & { _id?: mongo.Binary };
+const isWithId = <T extends ModelType>(o: T): o is WithId<T> => o && '_id' in o;
+
 
 /**
  * Basic mongo utils for conforming to the model module
  */
 export class MongoUtil {
 
-  static toIndex<T extends ModelType>(f: IndexField<T>) {
+  static toIndex<T extends ModelType>(f: IndexField<T>): Record<string, number> {
     const keys = [];
     while (typeof f !== 'number' && typeof f !== 'boolean' && Object.keys(f)) {
       const key = Object.keys(f)[0];
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       f = f[key as keyof typeof f] as IndexField<T>;
       keys.push(key);
     }
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const rf = f as unknown as (number | boolean);
-    return { [keys.join('.')]: rf === true ? 1 : rf } as Record<string, number>;
+    return {
+      [keys.join('.')]: typeof rf === 'boolean' ? (rf ? 1 : 0) : rf
+    };
   }
 
-  static uuid(val: string) {
+  static uuid(val: string): mongo.Binary {
     return new mongo.Binary(Buffer.from(val.replace(/-/g, ''), 'hex'), mongo.Binary.SUBTYPE_UUID);
   }
 
-  static idToString(id: string | mongo.ObjectId | mongo.Binary) {
+  static idToString(id: string | mongo.ObjectId | mongo.Binary): string {
     if (typeof id === 'string') {
       return id;
     } else if (id instanceof mongo.ObjectId) {
@@ -49,32 +55,41 @@ export class MongoUtil {
     }
   }
 
-  static async postLoadId<T extends ModelType>(item: T) {
-    if (item && '_id' in item) {
-      item.id = this.idToString((item as WithId<T>)._id);
-      delete (item as { _id?: unknown })._id;
+  static async postLoadId<T extends ModelType>(item: T): Promise<T> {
+    if (isWithId(item)) {
+      item.id = this.idToString(item._id!);
+      delete item._id;
     }
     return item;
   }
 
-  static preInsertId<T extends ModelType>(item: T) {
+  static preInsertId<T extends ModelType>(item: T): T {
     if (item && item.id) {
-      (item as WithId<T>)._id = this.uuid(item.id);
-      delete (item as { id?: unknown }).id;
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const itemWithId = item as WithId<T>;
+      itemWithId._id = this.uuid(item.id);
+      // @ts-expect-error
+      delete item.id;
     }
     return item;
   }
 
-  static prepareQuery<T extends ModelType, U extends Query<T> | ModelQuery<T>>(cls: Class<T>, query: U, checkExpiry = true) {
+  static prepareQuery<T extends ModelType, U extends Query<T> | ModelQuery<T>>(cls: Class<T>, query: U, checkExpiry = true): {
+    query: U & { where: WhereClause<T> };
+    filter: Record<string, unknown>;
+  } {
     const q = ModelQueryUtil.getQueryAndVerify(cls, query, checkExpiry);
     return {
       query: q,
       filter: q.where ? this.extractWhereClause(q.where) : {}
-    } as const;
+    };
   }
 
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   static has$And = (o: unknown): o is ({ $and: WhereClause<unknown>[] }) => !!o && '$and' in (o as object);
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   static has$Or = (o: unknown): o is ({ $or: WhereClause<unknown>[] }) => !!o && '$or' in (o as object);
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   static has$Not = (o: unknown): o is ({ $not: WhereClause<unknown> }) => !!o && '$not' in (o as object);
 
   /**
@@ -99,7 +114,7 @@ export class MongoUtil {
   static replaceId(v: string[]): mongo.Binary[];
   static replaceId(v: string): mongo.Binary;
   static replaceId(v: unknown): undefined;
-  static replaceId(v: string | string[] | Record<string, unknown> | unknown) {
+  static replaceId(v: string | string[] | Record<string, unknown> | unknown): unknown {
     if (typeof v === 'string') {
       return this.uuid(v);
     } else if (Array.isArray(v)) {
@@ -123,10 +138,12 @@ export class MongoUtil {
    */
   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
       const v = sub[key] as Record<string, unknown>;
 
       if (subpath === 'id') { // Handle ids directly
@@ -142,13 +159,17 @@ export class MongoUtil {
               v[sk] = ModelQueryUtil.resolveComparator(sv);
             }
           } else if (firstKey === '$regex') {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             v.$regex = Util.toRegex(v.$regex as string | RegExp);
           } else if (firstKey && '$near' in v) {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             const dist = v.$maxDistance as number;
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             const distance = dist / RADIANS_TO[(v.$unit as DistanceUnit ?? 'km')];
             v.$maxDistance = distance;
             delete v.$unit;
           } else if (firstKey && '$geoWithin' in v) {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             const coords = v.$geoWithin as [number, number][];
             const first = coords[0];
             const last = coords[coords.length - 1];

package/src/service.ts

@@ -1,10 +1,12 @@
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
 import * as mongo from 'mongodb';
+import { Readable } from 'stream';
 
 import {
   ModelRegistry, ModelType, OptionalId,
   ModelCrudSupport, ModelStorageSupport, ModelStreamSupport,
   ModelExpirySupport, ModelBulkSupport, ModelIndexedSupport,
-  StreamMeta, IndexField, BulkOp, BulkResponse,
+  StreamMeta, BulkOp, BulkResponse,
   NotFoundError, ExistsError, IndexConfig
 } from '@travetto/model';
 import {
@@ -33,10 +35,13 @@ import { MongoModelConfig } from './config';
 
 const IdxFieldsⲐ = Symbol.for('@trv:model-mongo/idx');
 
-const asFielded = <T extends ModelType>(cfg: IndexConfig<T>) => (cfg as unknown as { [IdxFieldsⲐ]: mongo.Sort });
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+const asFielded = <T extends ModelType>(cfg: IndexConfig<T>): { [IdxFieldsⲐ]: mongo.Sort } => (cfg as unknown as { [IdxFieldsⲐ]: mongo.Sort });
 
 type IdxCfg = mongo.CreateIndexesOptions;
 
+type StreamRaw = mongo.GridFSFile & { metadata: StreamMeta };
+
 /**
  * Mongo-based model source
  */
@@ -54,8 +59,9 @@ export class MongoModelService implements
 
   constructor(public readonly config: MongoModelConfig) { }
 
-  async #describeStreamRaw(location: string) {
-    const files = (await this.#bucket.find({ filename: location }, { limit: 1 }).toArray()) as (mongo.GridFSFile & { metadata: StreamMeta })[];
+  async #describeStreamRaw(location: string): Promise<StreamRaw> {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const files: StreamRaw[] = (await this.#bucket.find({ filename: location }, { limit: 1 }).toArray()) as StreamRaw[];
 
     if (!files?.length) {
       throw new NotFoundError(STREAMS, location);
@@ -64,7 +70,7 @@ export class MongoModelService implements
     return files[0];
   }
 
-  async postConstruct() {
+  async postConstruct(): Promise<void> {
     this.client = await mongo.MongoClient.connect(this.config.url, this.config.options);
     this.#db = this.client.db(this.config.namespace);
     this.#bucket = new mongo.GridFSBucket(this.#db, {
@@ -76,21 +82,21 @@ export class MongoModelService implements
     ModelExpiryUtil.registerCull(this);
   }
 
-  getWhere<T extends ModelType>(cls: Class<T>, where: WhereClause<T>, checkExpiry = true) {
+  getWhere<T extends ModelType>(cls: Class<T>, where: WhereClause<T>, checkExpiry = true): Record<string, unknown> {
     return MongoUtil.prepareQuery(cls, { where }, checkExpiry).filter;
   }
 
   /**
    * Build a mongo identifier
    */
-  uuid() {
+  uuid(): string {
     return Util.uuid();
   }
 
   // Storage
-  async createStorage() { }
+  async createStorage(): Promise<void> { }
 
-  async deleteStorage() {
+  async deleteStorage(): Promise<void> {
     await this.#db.dropDatabase();
   }
 
@@ -112,21 +118,22 @@ export class MongoModelService implements
     return out;
   }
 
-  getIndicies<T extends ModelType>(cls: Class<T>) {
+  getIndicies<T extends ModelType>(cls: Class<T>): ([mongo.IndexSpecification] | [mongo.IndexSpecification, IdxCfg])[] {
     const indices = ModelRegistry.get(cls).indices ?? [];
     return [
-      ...indices.map(idx => {
-        const combined = asFielded(idx)[IdxFieldsⲐ] ??= Object.assign({}, ...idx.fields.map(x => MongoUtil.toIndex(x as IndexField<T>)));
+      ...indices.map((idx): [mongo.IndexSpecification, IdxCfg] => {
+        const combined = asFielded(idx)[IdxFieldsⲐ] ??= Object.assign({}, ...idx.fields.map(x => MongoUtil.toIndex(x)));
         return [
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           combined as mongo.IndexSpecification,
-          (idx.type === 'unique' ? { unique: true } : {}) as IdxCfg
-        ] as const;
+          (idx.type === 'unique' ? { unique: true } : {})
+        ];
       }),
-      ...this.getGeoIndices(cls).map(x => [x] as const)
+      ...this.getGeoIndices(cls).map((x): [mongo.IndexSpecification] => [x])
     ];
   }
 
-  async establishIndices<T extends ModelType>(cls: Class<T>) {
+  async establishIndices<T extends ModelType>(cls: Class<T>): Promise<void> {
     const col = await this.getStore(cls);
     const creating = this.getIndicies(cls);
     if (creating.length) {
@@ -137,15 +144,15 @@ export class MongoModelService implements
     }
   }
 
-  async createModel(cls: Class) {
+  async createModel(cls: Class): Promise<void> {
     await this.establishIndices(cls);
   }
 
-  async changeModel(cls: Class) {
+  async changeModel(cls: Class): Promise<void> {
     await this.establishIndices(cls);
   }
 
-  async truncateModel<T extends ModelType>(cls: Class<T>) {
+  async truncateModel<T extends ModelType>(cls: Class<T>): Promise<void> {
     if (cls === StreamModel) {
       try {
         await this.#bucket.drop();
@@ -164,7 +171,7 @@ export class MongoModelService implements
   }
 
   // Crud
-  async get<T extends ModelType>(cls: Class<T>, id: string) {
+  async get<T extends ModelType>(cls: Class<T>, id: string): Promise<T> {
     const store = await this.getStore(cls);
     const result = await store.findOne(this.getWhere<ModelType>(cls, { id }), {});
     if (result) {
@@ -176,8 +183,9 @@ export class MongoModelService implements
     throw new NotFoundError(cls, id);
   }
 
-  async create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>) {
+  async create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T> {
     const cleaned = await ModelCrudUtil.preStore(cls, item, this);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     (cleaned as WithId<T>)._id = MongoUtil.uuid(cleaned.id);
 
     const store = await this.getStore(cls);
@@ -189,7 +197,7 @@ export class MongoModelService implements
     return cleaned;
   }
 
-  async update<T extends ModelType>(cls: Class<T>, item: T) {
+  async update<T extends ModelType>(cls: Class<T>, item: T): Promise<T> {
     item = await ModelCrudUtil.preStore(cls, item, this);
     const store = await this.getStore(cls);
     const res = await store.replaceOne(this.getWhere<ModelType>(cls, { id: item.id }), item);
@@ -199,7 +207,7 @@ export class MongoModelService implements
     return item;
   }
 
-  async upsert<T extends ModelType>(cls: Class<T>, item: OptionalId<T>) {
+  async upsert<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T> {
     const cleaned = await ModelCrudUtil.preStore(cls, item, this);
     const store = await this.getStore(cls);
     try {
@@ -209,7 +217,7 @@ export class MongoModelService implements
         { upsert: true }
       );
     } catch (err) {
-      if (err.message.includes('duplicate key error')) {
+      if (err instanceof Error && err.message.includes('duplicate key error')) {
         throw new ExistsError(cls, cleaned.id);
       } else {
         throw err;
@@ -218,7 +226,7 @@ export class MongoModelService implements
     return cleaned;
   }
 
-  async updatePartial<T extends ModelType>(cls: Class<T>, item: Partial<T> & { id: string }, view?: string) {
+  async updatePartial<T extends ModelType>(cls: Class<T>, item: Partial<T> & { id: string }, view?: string): Promise<T> {
     const store = await this.getStore(cls);
 
     if (view) {
@@ -232,16 +240,18 @@ export class MongoModelService implements
     let final: Record<string, unknown> = item;
 
     const items = MongoUtil.extractSimple(final);
-    final = Object.entries(items).reduce((acc, [k, v]) => {
-      if (v === null || v === undefined) {
-        const o = (acc.$unset = acc.$unset ?? {}) as Record<string, unknown>;
-        o[k] = v;
-      } else {
-        const o = (acc.$set = acc.$set ?? {}) as Record<string, unknown>;
-        o[k] = v;
-      }
-      return acc;
-    }, {} as Record<string, unknown>);
+    final = Object
+      .entries(items)
+      .reduce<Record<string, unknown>>((acc, [k, v]) => {
+        if (v === null || v === undefined) {
+          const o = (acc.$unset ??= {}) as Record<string, unknown>;
+          o[k] = v;
+        } else {
+          const o = (acc.$set ??= {}) as Record<string, unknown>;
+          o[k] = v;
+        }
+        return acc;
+      }, {});
 
     const id = item.id;
     const res = await store.findOneAndUpdate(
@@ -257,7 +267,7 @@ export class MongoModelService implements
     return this.get(cls, id);
   }
 
-  async delete<T extends ModelType>(cls: Class<T>, id: string) {
+  async delete<T extends ModelType>(cls: Class<T>, id: string): Promise<void> {
     const store = await this.getStore(cls);
     const result = await store.deleteOne(this.getWhere<ModelType>(cls, { id }, false));
     if (result.deletedCount === 0) {
@@ -265,22 +275,22 @@ export class MongoModelService implements
     }
   }
 
-  async * list<T extends ModelType>(cls: Class<T>) {
+  async * list<T extends ModelType>(cls: Class<T>): AsyncIterable<T> {
     const store = await this.getStore(cls);
     const cursor = store.find(this.getWhere(cls, {}), { timeout: true }).batchSize(100);
     for await (const el of cursor) {
       try {
         yield MongoUtil.postLoadId(await ModelCrudUtil.load(cls, el));
-      } catch (e) {
-        if (!(e instanceof NotFoundError)) {
-          throw e;
+      } catch (err) {
+        if (!(err instanceof NotFoundError)) {
+          throw err;
         }
       }
     }
   }
 
   // Stream
-  async upsertStream(location: string, input: NodeJS.ReadableStream, meta: StreamMeta) {
+  async upsertStream(location: string, input: Readable, meta: StreamMeta): Promise<void> {
     const writeStream = this.#bucket.openUploadStream(location, {
       contentType: meta.contentType,
       metadata: meta
@@ -293,7 +303,7 @@ export class MongoModelService implements
     });
   }
 
-  async getStream(location: string) {
+  async getStream(location: string): Promise<Readable> {
     await this.describeStream(location);
 
     const res = await this.#bucket.openDownloadStreamByName(location);
@@ -303,18 +313,18 @@ export class MongoModelService implements
     return res;
   }
 
-  async describeStream(location: string) {
+  async describeStream(location: string): Promise<StreamMeta> {
     return (await this.#describeStreamRaw(location)).metadata;
   }
 
-  async deleteStream(location: string) {
+  async deleteStream(location: string): Promise<void> {
     const fileId = (await this.#describeStreamRaw(location))._id;
     await this.#bucket.delete(fileId);
   }
 
   // Bulk
-  async processBulk<T extends ModelType>(cls: Class<T>, operations: BulkOp<T>[]) {
-    const out: BulkResponse = {
+  async processBulk<T extends ModelType>(cls: Class<T>, operations: BulkOp<T>[]): Promise<BulkResponse<{ index: number }>> {
+    const out: BulkResponse<{ index: number }> = {
       errors: [],
       counts: {
         delete: 0,
@@ -368,7 +378,7 @@ export class MongoModelService implements
 
     if (res.hasWriteErrors()) {
       out.errors = res.getWriteErrors();
-      for (const err of out.errors as { index: number }[]) {
+      for (const err of out.errors) {
         const op = operations[err.index];
         const k = Object.keys(op)[0] as keyof BulkResponse['counts'];
         out.counts[k] -= 1;
@@ -380,12 +390,12 @@ export class MongoModelService 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 store = await this.getStore(cls);
     const result = await store.findOne(
@@ -400,7 +410,7 @@ export class MongoModelService implements
     return await ModelCrudUtil.load(cls, result);
   }
 
-  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 store = await this.getStore(cls);
     const result = await store.deleteOne(
@@ -419,7 +429,7 @@ export class MongoModelService 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 store = await this.getStore(cls);
     const idxCfg = ModelRegistry.getIndex(cls, idx);
 
@@ -445,7 +455,8 @@ export class MongoModelService implements
     const { filter } = MongoUtil.prepareQuery(cls, query);
     let cursor = col.find<T>(filter, {});
     if (query.select) {
-      const select = Object.keys(query.select)[0].startsWith('$') ? query.select : MongoUtil.extractSimple(query.select);
+      const selectKey = Object.keys(query.select)[0];
+      const select = typeof selectKey === 'string' && selectKey.startsWith('$') ? query.select : MongoUtil.extractSimple(query.select);
       // Remove id if not explicitly defined, and selecting fields directly
       if (!select['_id']) {
         const values = new Set([...Object.values(select)]);
@@ -489,11 +500,11 @@ export class MongoModelService implements
     return res.deletedCount ?? 0;
   }
 
-  async updateByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>, data: Partial<T>) {
+  async updateByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>, data: Partial<T>): Promise<number> {
     const col = await this.getStore(cls);
 
     const items = MongoUtil.extractSimple(data);
-    const final = Object.entries(items).reduce((acc, [k, v]) => {
+    const final = Object.entries(items).reduce<Record<string, unknown>>((acc, [k, v]) => {
       if (v === null || v === undefined) {
         const o = (acc.$unset = acc.$unset ?? {}) as Record<string, unknown>;
         o[k] = v;
@@ -502,7 +513,7 @@ export class MongoModelService implements
         o[k] = v;
       }
       return acc;
-    }, {} as Record<string, unknown>);
+    }, {});
 
     const { filter } = MongoUtil.prepareQuery(cls, query);
     const res = await col.updateMany(filter, final);
@@ -514,7 +525,7 @@ export class MongoModelService implements
     const col = await this.getStore(cls);
     const pipeline: object[] = [{
       $group: {
-        _id: `$${field}`,
+        _id: `$${field as string}`,
         count: {
           $sum: 1
         }
@@ -541,7 +552,7 @@ export class MongoModelService implements
   async suggestValues<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>): Promise<string[]> {
     const q = ModelQuerySuggestUtil.getSuggestFieldQuery(cls, field, prefix, query);
     const results = await this.query(cls, q);
-    return ModelQuerySuggestUtil.combineSuggestResults(cls, field as 'type', prefix, results, (a) => a, query && query.limit);
+    return ModelQuerySuggestUtil.combineSuggestResults(cls, field, prefix, results, (a) => a, query && query.limit);
   }
 
   async suggest<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>): Promise<T[]> {