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

package/README.md

@@ -37,8 +37,8 @@ export class Init {
   @InjectableFactory({
     primary: true
   })
-  static getModelSource(conf: MongoModelConfig) {
-    return new MongoModelService(conf);
+  static getModelSource(config: MongoModelConfig) {
+    return new MongoModelService(config);
   }
 }
 ```
@@ -84,9 +84,9 @@ export class MongoModelConfig {
   options: mongo.MongoClientOptions = {};
 
   /**
-   * Should we auto create the db
+   * Allow storage modification at runtime
    */
-  autoCreate?: boolean;
+  modifyStorage?: boolean;
 
   /**
    * Frequency of culling for cullable content
@@ -107,11 +107,11 @@ export class MongoModelConfig {
    * Load all the ssl certs as needed
    */
   async postConstruct(): Promise<void> {
-    const resolve = (file: string): Promise<string> => RuntimeResources.resolve(file).then(v => v, () => file);
+    const resolve = (file: string): Promise<string> => RuntimeResources.resolve(file).catch(() => file);
 
     if (this.connectionString) {
       const details = new URL(this.connectionString);
-      this.hosts ??= details.hostname.split(',').filter(x => !!x);
+      this.hosts ??= details.hostname.split(',').filter(host => !!host);
       this.srvRecord ??= details.protocol === 'mongodb+srv:';
       this.namespace ??= details.pathname.replace('/', '');
       Object.assign(this.options, Object.fromEntries(details.searchParams.entries()));
@@ -131,24 +131,24 @@ export class MongoModelConfig {
       this.hosts = ['localhost'];
     }
 
-    const opts = this.options;
-    if (opts.ssl) {
-      if (opts.cert) {
-        opts.cert = await Promise.all([opts.cert].flat(2).map(f => Buffer.isBuffer(f) ? f : resolve(f)));
+    const options = this.options;
+    if (options.ssl) {
+      if (options.cert) {
+        options.cert = await Promise.all([options.cert].flat(2).map(data => Buffer.isBuffer(data) ? data : resolve(data)));
       }
-      if (opts.tlsCertificateKeyFile) {
-        opts.tlsCertificateKeyFile = await resolve(opts.tlsCertificateKeyFile);
+      if (options.tlsCertificateKeyFile) {
+        options.tlsCertificateKeyFile = await resolve(options.tlsCertificateKeyFile);
       }
-      if (opts.tlsCAFile) {
-        opts.tlsCAFile = await resolve(opts.tlsCAFile);
+      if (options.tlsCAFile) {
+        options.tlsCAFile = await resolve(options.tlsCAFile);
       }
-      if (opts.tlsCRLFile) {
-        opts.tlsCRLFile = await resolve(opts.tlsCRLFile);
+      if (options.tlsCRLFile) {
+        options.tlsCRLFile = await resolve(options.tlsCRLFile);
       }
     }
 
     if (!Runtime.production) {
-      opts.waitQueueTimeoutMS ??= TimeUtil.asMillis(1, 'd'); // Wait a day in dev mode
+      options.waitQueueTimeoutMS ??= TimeUtil.asMillis(1, 'd'); // Wait a day in dev mode
     }
   }
 
@@ -157,14 +157,14 @@ export class MongoModelConfig {
    */
   get url(): string {
     const hosts = this.hosts!
-      .map(h => (this.srvRecord || h.includes(':')) ? h : `${h}:${this.port ?? 27017}`)
+      .map(host => (this.srvRecord || host.includes(':')) ? host : `${host}:${this.port ?? 27017}`)
       .join(',');
-    const opts = Object.entries(this.options).map(([k, v]) => `${k}=${v}`).join('&');
+    const optionString = Object.entries(this.options).map(([key, value]) => `${key}=${value}`).join('&');
     let creds = '';
     if (this.username) {
-      creds = `${[this.username, this.password].filter(x => !!x).join(':')}@`;
+      creds = `${[this.username, this.password].filter(part => !!part).join(':')}@`;
     }
-    const url = `mongodb${this.srvRecord ? '+srv' : ''}://${creds}${hosts}/${this.namespace}?${opts}`;
+    const url = `mongodb${this.srvRecord ? '+srv' : ''}://${creds}${hosts}/${this.namespace}?${optionString}`;
     return url;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-mongo",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.3",
   "description": "Mongo backing for the travetto model module.",
   "keywords": [
     "mongo",
@@ -25,10 +25,10 @@
     "directory": "module/model-mongo"
   },
   "dependencies": {
-    "@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",
     "mongodb": "^7.0.0"
   },
   "travetto": {

package/src/config.ts

@@ -43,9 +43,9 @@ export class MongoModelConfig {
   options: mongo.MongoClientOptions = {};
 
   /**
-   * Should we auto create the db
+   * Allow storage modification at runtime
    */
-  autoCreate?: boolean;
+  modifyStorage?: boolean;
 
   /**
    * Frequency of culling for cullable content
@@ -66,11 +66,11 @@ export class MongoModelConfig {
    * Load all the ssl certs as needed
    */
   async postConstruct(): Promise<void> {
-    const resolve = (file: string): Promise<string> => RuntimeResources.resolve(file).then(v => v, () => file);
+    const resolve = (file: string): Promise<string> => RuntimeResources.resolve(file).catch(() => file);
 
     if (this.connectionString) {
       const details = new URL(this.connectionString);
-      this.hosts ??= details.hostname.split(',').filter(x => !!x);
+      this.hosts ??= details.hostname.split(',').filter(host => !!host);
       this.srvRecord ??= details.protocol === 'mongodb+srv:';
       this.namespace ??= details.pathname.replace('/', '');
       Object.assign(this.options, Object.fromEntries(details.searchParams.entries()));
@@ -90,24 +90,24 @@ export class MongoModelConfig {
       this.hosts = ['localhost'];
     }
 
-    const opts = this.options;
-    if (opts.ssl) {
-      if (opts.cert) {
-        opts.cert = await Promise.all([opts.cert].flat(2).map(f => Buffer.isBuffer(f) ? f : resolve(f)));
+    const options = this.options;
+    if (options.ssl) {
+      if (options.cert) {
+        options.cert = await Promise.all([options.cert].flat(2).map(data => Buffer.isBuffer(data) ? data : resolve(data)));
       }
-      if (opts.tlsCertificateKeyFile) {
-        opts.tlsCertificateKeyFile = await resolve(opts.tlsCertificateKeyFile);
+      if (options.tlsCertificateKeyFile) {
+        options.tlsCertificateKeyFile = await resolve(options.tlsCertificateKeyFile);
       }
-      if (opts.tlsCAFile) {
-        opts.tlsCAFile = await resolve(opts.tlsCAFile);
+      if (options.tlsCAFile) {
+        options.tlsCAFile = await resolve(options.tlsCAFile);
       }
-      if (opts.tlsCRLFile) {
-        opts.tlsCRLFile = await resolve(opts.tlsCRLFile);
+      if (options.tlsCRLFile) {
+        options.tlsCRLFile = await resolve(options.tlsCRLFile);
       }
     }
 
     if (!Runtime.production) {
-      opts.waitQueueTimeoutMS ??= TimeUtil.asMillis(1, 'd'); // Wait a day in dev mode
+      options.waitQueueTimeoutMS ??= TimeUtil.asMillis(1, 'd'); // Wait a day in dev mode
     }
   }
 
@@ -116,14 +116,14 @@ export class MongoModelConfig {
    */
   get url(): string {
     const hosts = this.hosts!
-      .map(h => (this.srvRecord || h.includes(':')) ? h : `${h}:${this.port ?? 27017}`)
+      .map(host => (this.srvRecord || host.includes(':')) ? host : `${host}:${this.port ?? 27017}`)
       .join(',');
-    const opts = Object.entries(this.options).map(([k, v]) => `${k}=${v}`).join('&');
+    const optionString = Object.entries(this.options).map(([key, value]) => `${key}=${value}`).join('&');
     let creds = '';
     if (this.username) {
-      creds = `${[this.username, this.password].filter(x => !!x).join(':')}@`;
+      creds = `${[this.username, this.password].filter(part => !!part).join(':')}@`;
     }
-    const url = `mongodb${this.srvRecord ? '+srv' : ''}://${creds}${hosts}/${this.namespace}?${opts}`;
+    const url = `mongodb${this.srvRecord ? '+srv' : ''}://${creds}${hosts}/${this.namespace}?${optionString}`;
     return url;
   }
 }

package/src/internal/util.ts

@@ -1,5 +1,6 @@
 import {
-  Binary, type CreateIndexesOptions, type Filter, type FindCursor, type IndexDirection, ObjectId, type WithId as MongoWithId
+  Binary, type CreateIndexesOptions, type Filter, type FindCursor, type IndexDirection, ObjectId, type WithId as MongoWithId,
+  type IndexDescriptionInfo
 } from 'mongodb';
 
 import { AppError, castTo, Class, toConcrete, TypedObject } from '@travetto/runtime';
@@ -7,9 +8,9 @@ import { type DistanceUnit, type PageableModelQuery, type WhereClause, ModelQuer
 import type { ModelType, IndexField, IndexConfig } from '@travetto/model';
 import { DataUtil, SchemaRegistryIndex, type Point } from '@travetto/schema';
 
-const PointImpl = toConcrete<Point>();
+const PointConcrete = toConcrete<Point>();
 
-type IdxCfg = CreateIndexesOptions;
+type IdxConfig = CreateIndexesOptions;
 
 /**
  * Converting units to various radians
@@ -31,21 +32,21 @@ export type PlainIdx = Record<string, -1 | 0 | 1>;
  */
 export class MongoUtil {
 
-  static toIndex<T extends ModelType>(f: IndexField<T>): PlainIdx {
+  static toIndex<T extends ModelType>(field: IndexField<T>): PlainIdx {
     const keys = [];
-    while (typeof f !== 'number' && typeof f !== 'boolean' && Object.keys(f)) {
-      const key = TypedObject.keys(f)[0];
-      f = castTo(f[key]);
+    while (typeof field !== 'number' && typeof field !== 'boolean' && Object.keys(field)) {
+      const key = TypedObject.keys(field)[0];
+      field = castTo(field[key]);
       keys.push(key);
     }
-    const rf: number | boolean = castTo(f);
+    const rf: number | boolean = castTo(field);
     return {
       [keys.join('.')]: typeof rf === 'boolean' ? (rf ? 1 : 0) : castTo<-1 | 1 | 0>(rf)
     };
   }
 
-  static uuid(val: string): Binary {
-    return new Binary(Buffer.from(val.replaceAll('-', ''), 'hex'), Binary.SUBTYPE_UUID);
+  static uuid(value: string): Binary {
+    return new Binary(Buffer.from(value.replaceAll('-', ''), 'hex'), Binary.SUBTYPE_UUID);
   }
 
   static idToString(id: string | ObjectId | Binary): string {
@@ -66,84 +67,84 @@ export class MongoUtil {
   /**
    * Build mongo where clause
    */
-  static extractWhereClause<T>(cls: Class<T>, o: WhereClause<T>): Record<string, unknown> {
-    if (ModelQueryUtil.has$And(o)) {
-      return { $and: o.$and.map(x => this.extractWhereClause<T>(cls, x)) };
-    } else if (ModelQueryUtil.has$Or(o)) {
-      return { $or: o.$or.map(x => this.extractWhereClause<T>(cls, x)) };
-    } else if (ModelQueryUtil.has$Not(o)) {
-      return { $nor: [this.extractWhereClause<T>(cls, o.$not)] };
+  static extractWhereClause<T>(cls: Class<T>, clause: WhereClause<T>): Record<string, unknown> {
+    if (ModelQueryUtil.has$And(clause)) {
+      return { $and: clause.$and.map(item => this.extractWhereClause<T>(cls, item)) };
+    } else if (ModelQueryUtil.has$Or(clause)) {
+      return { $or: clause.$or.map(item => this.extractWhereClause<T>(cls, item)) };
+    } else if (ModelQueryUtil.has$Not(clause)) {
+      return { $nor: [this.extractWhereClause<T>(cls, clause.$not)] };
     } else {
-      return this.extractSimple(cls, o);
+      return this.extractSimple(cls, clause);
     }
   }
 
   /**/
-  static extractSimple<T>(base: Class<T> | undefined, o: Record<string, unknown>, path: string = '', recursive: boolean = true): Record<string, unknown> {
+  static extractSimple<T>(base: Class<T> | undefined, item: Record<string, unknown>, path: string = '', recursive: boolean = true): Record<string, unknown> {
     const fields = base ? SchemaRegistryIndex.getOptional(base)?.getFields() : undefined;
     const out: Record<string, unknown> = {};
-    const sub = o;
+    const sub = item;
     const keys = Object.keys(sub);
     for (const key of keys) {
       const subpath = `${path}${key}`;
-      const v: Record<string, unknown> = castTo(sub[key]);
+      const value: Record<string, unknown> = castTo(sub[key]);
       const subField = fields?.[key];
 
-      const isPlain = v && DataUtil.isPlainObject(v);
-      const firstKey = isPlain ? Object.keys(v)[0] : '';
+      const isPlain = value && DataUtil.isPlainObject(value);
+      const firstKey = isPlain ? Object.keys(value)[0] : '';
 
       if (subpath === 'id') {
         if (!firstKey) {
-          out._id = Array.isArray(v) ? v.map(x => this.uuid(x)) : this.uuid(`${v}`);
+          out._id = Array.isArray(value) ? value.map(subValue => this.uuid(subValue)) : this.uuid(`${value}`);
         } else if (firstKey === '$in' || firstKey === '$nin' || firstKey === '$eq' || firstKey === '$ne') {
-          const temp = v[firstKey];
-          out._id = { [firstKey]: Array.isArray(temp) ? temp.map(x => this.uuid(x)) : this.uuid(`${temp}`) };
+          const temp = value[firstKey];
+          out._id = { [firstKey]: Array.isArray(temp) ? temp.map(subValue => this.uuid(subValue)) : this.uuid(`${temp}`) };
         } else {
           throw new AppError('Invalid id query');
         }
-      } else if ((isPlain && !firstKey.startsWith('$')) || v?.constructor?.Ⲑid) {
+      } else if ((isPlain && !firstKey.startsWith('$')) || value?.constructor?.Ⲑid) {
         if (recursive) {
-          Object.assign(out, this.extractSimple(subField?.type, v, `${subpath}.`, recursive));
+          Object.assign(out, this.extractSimple(subField?.type, value, `${subpath}.`, recursive));
         } else {
-          out[subpath] = v;
+          out[subpath] = value;
         }
       } else {
         if (firstKey === '$gt' || firstKey === '$lt' || firstKey === '$gte' || firstKey === '$lte') {
-          for (const [sk, sv] of Object.entries(v)) {
-            v[sk] = ModelQueryUtil.resolveComparator(sv);
+          for (const [sk, sv] of Object.entries(value)) {
+            value[sk] = ModelQueryUtil.resolveComparator(sv);
           }
         } else if (firstKey === '$exists' && subField?.array) {
-          const exists = v.$exists;
+          const exists = value.$exists;
           if (!exists) {
-            delete v.$exists;
-            v.$in = [null, []];
+            delete value.$exists;
+            value.$in = [null, []];
           } else {
-            v.$exists = true;
-            v.$nin = [null, []];
+            value.$exists = true;
+            value.$nin = [null, []];
           }
         } else if (firstKey === '$regex') {
-          v.$regex = DataUtil.toRegex(castTo(v.$regex));
-        } else if (firstKey && '$near' in v) {
-          const dist: number = castTo(v.$maxDistance);
-          const distance = dist / RADIANS_TO[(castTo<DistanceUnit>(v.$unit) ?? 'km')];
-          v.$maxDistance = distance;
-          delete v.$unit;
-        } else if (firstKey && '$geoWithin' in v) {
-          const coords: [number, number][] = castTo(v.$geoWithin);
+          value.$regex = DataUtil.toRegex(castTo(value.$regex));
+        } else if (firstKey && '$near' in value) {
+          const dist: number = castTo(value.$maxDistance);
+          const distance = dist / RADIANS_TO[(castTo<DistanceUnit>(value.$unit) ?? 'km')];
+          value.$maxDistance = distance;
+          delete value.$unit;
+        } else if (firstKey && '$geoWithin' in value) {
+          const coords: [number, number][] = castTo(value.$geoWithin);
           const first = coords[0];
           const last = coords.at(-1)!;
           // Connect if not
           if (first[0] !== last[0] || first[1] !== last[1]) {
             coords.push(first);
           }
-          v.$geoWithin = {
+          value.$geoWithin = {
             $geometry: {
               type: 'Polygon',
               coordinates: [coords]
             }
           };
         }
-        out[subpath === 'id' ? '_id' : subpath] = v;
+        out[subpath === 'id' ? '_id' : subpath] = value;
       }
     }
     return out;
@@ -153,11 +154,11 @@ export class MongoUtil {
     const out: BasicIdx[] = [];
     const textFields: string[] = [];
     SchemaRegistryIndex.visitFields(cls, (field, path) => {
-      if (field.type === PointImpl) {
-        const name = [...path, field].map(x => x.name).join('.');
+      if (field.type === PointConcrete) {
+        const name = [...path, field].map(schema => schema.name).join('.');
         out.push({ [name]: '2d' });
       } else if (field.specifiers?.includes('text') && (field.specifiers?.includes('long') || field.specifiers.includes('search'))) {
-        const name = [...path, field].map(x => x.name).join('.');
+        const name = [...path, field].map(schema => schema.name).join('.');
         textFields.push(name);
       }
     });
@@ -173,17 +174,17 @@ export class MongoUtil {
 
   static getPlainIndex(idx: IndexConfig<ModelType>): PlainIdx {
     let out: PlainIdx = {};
-    for (const cfg of idx.fields.map(x => this.toIndex(x))) {
-      out = Object.assign(out, cfg);
+    for (const config of idx.fields.map(value => this.toIndex(value))) {
+      out = Object.assign(out, config);
     }
     return out;
   }
 
-  static getIndices<T extends ModelType>(cls: Class<T>, indices: IndexConfig<ModelType>[] = []): [BasicIdx, IdxCfg][] {
+  static getIndices<T extends ModelType>(cls: Class<T>, indices: IndexConfig<ModelType>[] = []): [BasicIdx, IdxConfig][] {
     return [
       ...indices.map(idx => [this.getPlainIndex(idx), (idx.type === 'unique' ? { unique: true } : {})] as const),
-      ...this.getExtraIndices(cls).map((x) => [x, {}] as const)
-    ].map(x => [...x]);
+      ...this.getExtraIndices(cls).map((idx) => [idx, {}] as const)
+    ].map(idx => [...idx]);
   }
 
   static prepareCursor<T extends ModelType>(cls: Class<T>, cursor: FindCursor<T | MongoWithId<T>>, query: PageableModelQuery<T>): FindCursor<T> {
@@ -201,7 +202,7 @@ export class MongoUtil {
     }
 
     if (query.sort) {
-      cursor = cursor.sort(Object.assign({}, ...query.sort.map(x => this.extractSimple(cls, x))));
+      cursor = cursor.sort(Object.assign({}, ...query.sort.map(item => this.extractSimple(cls, item))));
     }
 
     cursor = cursor.limit(Math.trunc(query.limit ?? 200));
@@ -212,4 +213,33 @@ export class MongoUtil {
 
     return castTo(cursor);
   }
+
+  static isIndexChanged(existing: IndexDescriptionInfo, [pendingKey, pendingOptions]: [BasicIdx, CreateIndexesOptions]): boolean {
+    // Config changed
+    if (
+      !!existing.unique !== !!pendingOptions.unique ||
+      !!existing.sparse !== !!pendingOptions.sparse ||
+      existing.expireAfterSeconds !== pendingOptions.expireAfterSeconds ||
+      existing.bucketSize !== pendingOptions.bucketSize
+    ) {
+      return true;
+    }
+    const pendingKeySet = new Set(Object.keys(pendingKey));
+    const existingKeySet = new Set(Object.keys(existing.key));
+
+    if (pendingKeySet.size !== existingKeySet.size) {
+      return true;
+    }
+
+    const overlap = pendingKeySet.intersection(existingKeySet);
+    if (overlap.size !== pendingKeySet.size) {
+      return true;
+    }
+    for (const key of overlap) {
+      if (existing.key[key] !== pendingKey[key]) {
+        return false;
+      }
+    }
+    return false;
+  }
 }

package/src/service.ts

@@ -3,12 +3,12 @@ import { pipeline } from 'node:stream/promises';
 import {
   type Db, GridFSBucket, MongoClient, type GridFSFile, type Collection,
   type ObjectId, type Binary, type RootFilterOperators, type Filter,
-  type WithId as MongoWithId
+  type WithId as MongoWithId,
 } from 'mongodb';
 
 import {
   ModelRegistryIndex, ModelType, OptionalId, ModelCrudSupport, ModelStorageSupport,
-  ModelExpirySupport, ModelBulkSupport, ModelIndexedSupport, BulkOp, BulkResponse,
+  ModelExpirySupport, ModelBulkSupport, ModelIndexedSupport, BulkOperation, BulkResponse,
   NotFoundError, ExistsError, ModelBlobSupport,
   ModelCrudUtil, ModelIndexedUtil, ModelStorageUtil, ModelExpiryUtil, ModelBulkUtil, ModelBlobUtil,
 } from '@travetto/model';
@@ -106,7 +106,7 @@ export class MongoModelService implements
       bucketName: ModelBlobNamespace,
       writeConcern: { w: 1 }
     });
-    await ModelStorageUtil.registerModelChangeListener(this);
+    await ModelStorageUtil.storageInitialization(this);
     ShutdownManager.onGracefulShutdown(() => this.client.close());
     ModelExpiryUtil.registerCull(this);
   }
@@ -126,23 +126,34 @@ export class MongoModelService implements
     await this.#db.dropDatabase();
   }
 
-  async establishIndices<T extends ModelType>(cls: Class<T>): Promise<void> {
+  async upsertModel(cls: Class): Promise<void> {
     const col = await this.getStore(cls);
-    const creating = MongoUtil.getIndices(cls, ModelRegistryIndex.getConfig(cls).indices);
-    if (creating.length) {
-      console.debug('Creating indexes', { indices: creating });
-      for (const el of creating) {
-        await col.createIndex(...el);
-      }
-    }
-  }
+    const indices = MongoUtil.getIndices(cls, ModelRegistryIndex.getConfig(cls).indices);
+    const existingIndices = (await col.indexes().catch(() => [])).filter(idx => idx.name !== '_id_');
 
-  async createModel(cls: Class): Promise<void> {
-    await this.establishIndices(cls);
-  }
+    const pendingMap = Object.fromEntries(indices.map(pair => [pair[1].name!, pair]));
+    const existingMap = Object.fromEntries(existingIndices.map(idx => [idx.name!, idx.key]));
 
-  async changeModel(cls: Class): Promise<void> {
-    await this.establishIndices(cls);
+    for (const idx of existingIndices) {
+      if (!idx.name) {
+        continue;
+      }
+      const pending = pendingMap[idx.name];
+      if (!pending) {
+        console.debug('Deleting index', { indices: idx.name });
+        await col.dropIndex(idx.name);
+      } else if (MongoUtil.isIndexChanged(idx, pending)) {
+        console.debug('Updating index', { indices: idx.name });
+        await col.dropIndex(idx.name);
+        await col.createIndex(...pending);
+      }
+    }
+    for (const [name, idx] of Object.entries(pendingMap)) {
+      if (!existingMap[name]) {
+        console.debug('Creating index', { indices: name });
+        await col.createIndex(...idx);
+      }
+    }
   }
 
   async truncateModel<T extends ModelType>(cls: Class<T>): Promise<void> {
@@ -158,7 +169,7 @@ export class MongoModelService implements
    * Get mongo collection
    */
   async getStore<T extends ModelType>(cls: Class<T>): Promise<Collection<T>> {
-    return this.#db.collection(ModelRegistryIndex.getStoreName(cls).toLowerCase().replace(/[^A-Za-z0-9_]+/g, '_'));
+    return this.#db.collection(ModelRegistryIndex.getStoreName(cls));
   }
 
   // Crud
@@ -208,11 +219,11 @@ export class MongoModelService implements
         { $set: cleaned },
         { upsert: true }
       );
-    } catch (err) {
-      if (err instanceof Error && err.message.includes('duplicate key error')) {
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('duplicate key error')) {
         throw new ExistsError(cls, id);
       } else {
-        throw err;
+        throw error;
       }
     }
     return this.postUpdate(cleaned, id);
@@ -226,13 +237,13 @@ export class MongoModelService implements
 
     const operation: Partial<T> = castTo(Object
       .entries(simple)
-      .reduce<Partial<Record<'$unset' | '$set', Record<string, unknown>>>>((acc, [k, v]) => {
-        if (v === null || v === undefined) {
-          (acc.$unset ??= {})[k] = v;
+      .reduce<Partial<Record<'$unset' | '$set', Record<string, unknown>>>>((document, [key, value]) => {
+        if (value === null || value === undefined) {
+          (document.$unset ??= {})[key] = value;
         } else {
-          (acc.$set ??= {})[k] = v;
+          (document.$set ??= {})[key] = value;
         }
-        return acc;
+        return document;
       }, {}));
 
     const id = item.id;
@@ -261,12 +272,12 @@ export class MongoModelService implements
   async * list<T extends ModelType>(cls: Class<T>): AsyncIterable<T> {
     const store = await this.getStore(cls);
     const cursor = store.find(this.getWhereFilter(cls, {}), { timeout: true }).batchSize(100);
-    for await (const el of cursor) {
+    for await (const item of cursor) {
       try {
-        yield await this.postLoad(cls, el);
-      } catch (err) {
-        if (!(err instanceof NotFoundError)) {
-          throw err;
+        yield await this.postLoad(cls, item);
+      } catch (error) {
+        if (!(error instanceof NotFoundError)) {
+          throw error;
         }
       }
     }
@@ -313,7 +324,7 @@ export class MongoModelService implements
   }
 
   // Bulk
-  async processBulk<T extends ModelType>(cls: Class<T>, operations: BulkOp<T>[]): Promise<BulkResponse<{ index: number }>> {
+  async processBulk<T extends ModelType>(cls: Class<T>, operations: BulkOperation<T>[]): Promise<BulkResponse<{ index: number }>> {
     const out: BulkResponse<{ index: number }> = {
       errors: [],
       counts: {
@@ -336,26 +347,26 @@ export class MongoModelService implements
 
     out.insertedIds = new Map([...upsertedIds.entries(), ...insertedIds.entries()]);
 
-    for (const op of operations) {
-      if (op.insert) {
-        this.preUpdate(op.insert);
-        bulk.insert(op.insert);
-      } else if (op.upsert) {
-        const id = this.preUpdate(op.upsert);
-        bulk.find({ _id: MongoUtil.uuid(id!) }).upsert().updateOne({ $set: op.upsert });
-      } else if (op.update) {
-        const id = this.preUpdate(op.update);
-        bulk.find({ _id: MongoUtil.uuid(id) }).update({ $set: op.update });
-      } else if (op.delete) {
-        bulk.find({ _id: MongoUtil.uuid(op.delete.id) }).deleteOne();
+    for (const operation of operations) {
+      if (operation.insert) {
+        this.preUpdate(operation.insert);
+        bulk.insert(operation.insert);
+      } else if (operation.upsert) {
+        const id = this.preUpdate(operation.upsert);
+        bulk.find({ _id: MongoUtil.uuid(id!) }).upsert().updateOne({ $set: operation.upsert });
+      } else if (operation.update) {
+        const id = this.preUpdate(operation.update);
+        bulk.find({ _id: MongoUtil.uuid(id) }).update({ $set: operation.update });
+      } else if (operation.delete) {
+        bulk.find({ _id: MongoUtil.uuid(operation.delete.id) }).deleteOne();
       }
     }
 
     const result = await bulk.execute({});
 
     // Restore all ids
-    for (const op of operations) {
-      const core = op.insert ?? op.upsert ?? op.update;
+    for (const operation of operations) {
+      const core = operation.insert ?? operation.upsert ?? operation.update;
       if (core) {
         this.postUpdate(asFull(core));
       }
@@ -367,17 +378,17 @@ export class MongoModelService implements
 
     if (out.counts) {
       out.counts.delete = result.deletedCount;
-      out.counts.update = operations.filter(x => x.update).length;
+      out.counts.update = operations.filter(item => item.update).length;
       out.counts.insert = result.insertedCount;
-      out.counts.upsert = operations.filter(x => x.upsert).length;
+      out.counts.upsert = operations.filter(item => item.upsert).length;
     }
 
     if (result.hasWriteErrors()) {
       out.errors = result.getWriteErrors();
-      for (const err of out.errors) {
-        const op = operations[err.index];
-        const k = TypedObject.keys(op)[0];
-        out.counts[k] -= 1;
+      for (const error of out.errors) {
+        const operation = operations[error.index];
+        const key = TypedObject.keys(operation)[0];
+        out.counts[key] -= 1;
       }
       out.counts.error = out.errors.length;
     }
@@ -427,18 +438,18 @@ export class MongoModelService implements
 
   async * listByIndex<T extends ModelType>(cls: Class<T>, idx: string, body?: DeepPartial<T>): AsyncIterable<T> {
     const store = await this.getStore(cls);
-    const idxCfg = ModelRegistryIndex.getIndex(cls, idx, ['sorted', 'unsorted']);
+    const idxConfig = ModelRegistryIndex.getIndex(cls, idx, ['sorted', 'unsorted']);
 
     const where = this.getWhereFilter(
       cls,
       castTo(ModelIndexedUtil.projectIndex(cls, idx, body, { emptySortValue: { $exists: true } }))
     );
 
-    const sort = castTo<{ [ListIndexSymbol]: PlainIdx }>(idxCfg)[ListIndexSymbol] ??= MongoUtil.getPlainIndex(idxCfg);
+    const sort = castTo<{ [ListIndexSymbol]: PlainIdx }>(idxConfig)[ListIndexSymbol] ??= MongoUtil.getPlainIndex(idxConfig);
     const cursor = store.find(where, { timeout: true }).batchSize(100).sort(castTo(sort));
 
-    for await (const el of cursor) {
-      yield await this.postLoad(cls, el);
+    for await (const item of cursor) {
+      yield await this.postLoad(cls, item);
     }
   }
 
@@ -450,7 +461,7 @@ export class MongoModelService implements
     const filter = MongoUtil.extractWhereFilter(cls, query.where);
     const cursor = col.find(filter, {});
     const items = await MongoUtil.prepareCursor(cls, cursor, query).toArray();
-    return await Promise.all(items.map(r => this.postLoad(cls, r)));
+    return await Promise.all(items.map(item => this.postLoad(cls, item)));
   }
 
   async queryCount<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number> {
@@ -500,13 +511,13 @@ export class MongoModelService implements
     const col = await this.getStore(cls);
     const items = MongoUtil.extractSimple(cls, item);
     const final = Object.entries(items).reduce<Partial<Record<'$unset' | '$set', Record<string, unknown>>>>(
-      (acc, [k, v]) => {
-        if (v === null || v === undefined) {
-          (acc.$unset ??= {})[k] = v;
+      (document, [key, value]) => {
+        if (value === null || value === undefined) {
+          (document.$unset ??= {})[key] = value;
         } else {
-          (acc.$set ??= {})[k] = v;
+          (document.$set ??= {})[key] = value;
         }
-        return acc;
+        return document;
       }, {});
 
     const filter = MongoUtil.extractWhereFilter(cls, query.where);
@@ -523,14 +534,14 @@ export class MongoModelService implements
       await QueryVerifier.verify(cls, query);
     }
 
-    let q: Record<string, unknown> = { [field]: { $exists: true } };
+    let queryObject: Record<string, unknown> = { [field]: { $exists: true } };
 
     if (query?.where) {
-      q = { $and: [q, MongoUtil.extractWhereFilter(cls, query.where)] };
+      queryObject = { $and: [queryObject, MongoUtil.extractWhereFilter(cls, query.where)] };
     }
 
     const aggregations: object[] = [
-      { $match: q },
+      { $match: queryObject },
       {
         $group: {
           _id: `$${field}`,
@@ -544,9 +555,9 @@ export class MongoModelService implements
     const result = await col.aggregate<{ _id: ObjectId, count: number }>(aggregations).toArray();
 
     return result
-      .map(val => ({
-        key: MongoUtil.idToString(val._id),
-        count: val.count
+      .map(item => ({
+        key: MongoUtil.idToString(item._id),
+        count: item.count
       }))
       .toSorted((a, b) => b.count - a.count);
   }
@@ -554,15 +565,15 @@ export class MongoModelService implements
   // Suggest
   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.getSuggestFieldQuery<T>(cls, field, prefix, query);
-    const results = await this.query<T>(cls, q);
+    const resolvedQuery = ModelQuerySuggestUtil.getSuggestFieldQuery<T>(cls, field, prefix, query);
+    const results = await this.query<T>(cls, resolvedQuery);
     return ModelQuerySuggestUtil.combineSuggestResults<T, string>(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[]> {
     await QueryVerifier.verify(cls, query);
-    const q = ModelQuerySuggestUtil.getSuggestQuery<T>(cls, field, prefix, query);
-    const results = await this.query<T>(cls, q);
+    const resolvedQuery = ModelQuerySuggestUtil.getSuggestQuery<T>(cls, field, prefix, query);
+    const results = await this.query<T>(cls, resolvedQuery);
     return ModelQuerySuggestUtil.combineSuggestResults(cls, field, prefix, results, (_, b) => b, query && query.limit);
   }
 
@@ -582,6 +593,6 @@ export class MongoModelService implements
 
     const cursor = col.find(castTo({ $and: [{ $text: search }, filter] }), {});
     const items = await MongoUtil.prepareCursor(cls, cursor, query).toArray();
-    return await Promise.all(items.map(r => this.postLoad(cls, r)));
+    return await Promise.all(items.map(item => this.postLoad(cls, item)));
   }
 }