@travetto/model-mongo 5.0.0-rc.1 → 5.0.0-rc.10

package/README.md

@@ -48,7 +48,7 @@ where the [MongoModelConfig](https://github.com/travetto/travetto/tree/main/modu
 ```typescript
 import type mongo from 'mongodb';
 
-import { Env, TimeSpan, TimeUtil, RuntimeResources } from '@travetto/base';
+import { TimeSpan, TimeUtil, RuntimeResources, Runtime } from '@travetto/runtime';
 import { Config } from '@travetto/config';
 import { Field } from '@travetto/schema';
 
@@ -151,7 +151,7 @@ export class MongoModelConfig {
       }
     }
 
-    if (!Env.production) {
+    if (!Runtime.production) {
       opts.waitQueueTimeoutMS ??= TimeUtil.asMillis(1, 'd'); // Wait a day in dev mode
     }
   }
@@ -174,4 +174,4 @@ export class MongoModelConfig {
 }
 ```
 
-Additionally, you can see that the class is registered with the [@Config](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L13) annotation, and so these values can be overridden using the standard [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support") resolution paths.The SSL file options in `clientOptions` will automatically be resolved to files when given a path.  This path can be a resource path (will attempt to lookup using [RuntimeResources](https://github.com/travetto/travetto/tree/main/module/base/src/runtime.ts#L8)) or just a standard file path.
+Additionally, you can see that the class is registered with the [@Config](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L13) annotation, and so these values can be overridden using the standard [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support") resolution paths.The SSL file options in `clientOptions` will automatically be resolved to files when given a path.  This path can be a resource path (will attempt to lookup using [RuntimeResources](https://github.com/travetto/travetto/tree/main/module/runtime/src/resources.ts#L8)) or just a standard file path.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-mongo",
-  "version": "5.0.0-rc.1",
+  "version": "5.0.0-rc.10",
   "description": "Mongo backing for the travetto model module.",
   "keywords": [
     "mongo",
@@ -25,13 +25,13 @@
     "directory": "module/model-mongo"
   },
   "dependencies": {
-    "@travetto/config": "^5.0.0-rc.1",
-    "@travetto/model": "^5.0.0-rc.1",
-    "@travetto/model-query": "^5.0.0-rc.0",
+    "@travetto/config": "^5.0.0-rc.10",
+    "@travetto/model": "^5.0.0-rc.10",
+    "@travetto/model-query": "^5.0.0-rc.10",
     "mongodb": "^6.8.0"
   },
   "peerDependencies": {
-    "@travetto/command": "^5.0.0-rc.0"
+    "@travetto/command": "^5.0.0-rc.9"
   },
   "peerDependenciesMeta": {
     "@travetto/command": {

package/src/config.ts

@@ -1,6 +1,6 @@
 import type mongo from 'mongodb';
 
-import { Env, TimeSpan, TimeUtil, RuntimeResources } from '@travetto/base';
+import { TimeSpan, TimeUtil, RuntimeResources, Runtime } from '@travetto/runtime';
 import { Config } from '@travetto/config';
 import { Field } from '@travetto/schema';
 
@@ -103,7 +103,7 @@ export class MongoModelConfig {
       }
     }
 
-    if (!Env.production) {
+    if (!Runtime.production) {
       opts.waitQueueTimeoutMS ??= TimeUtil.asMillis(1, 'd'); // Wait a day in dev mode
     }
   }

package/src/internal/util.ts

@@ -1,7 +1,7 @@
 import { Binary, ObjectId } from 'mongodb';
 
-import { Class } from '@travetto/base';
-import { DistanceUnit, ModelQuery, Query, WhereClause } from '@travetto/model-query';
+import { castTo, Class, TypedObject } from '@travetto/runtime';
+import { DistanceUnit, WhereClause } from '@travetto/model-query';
 import type { ModelType, IndexField } from '@travetto/model';
 import { DataUtil, SchemaRegistry } from '@travetto/schema';
 import { ModelQueryUtil } from '@travetto/model-query/src/internal/service/query';
@@ -18,8 +18,8 @@ const RADIANS_TO: Record<DistanceUnit, number> = {
   rad: 1
 };
 
-export type WithId<T> = T & { _id?: Binary };
-const isWithId = <T extends ModelType>(o: T): o is WithId<T> => o && '_id' in o;
+export type WithId<T, I = unknown> = T & { _id?: I };
+const isWithId = <T extends ModelType, I = unknown>(o: T): o is WithId<T, I> => o && '_id' in o;
 
 /**
  * Basic mongo utils for conforming to the model module
@@ -29,20 +29,18 @@ export class MongoUtil {
   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>;
+      const key = TypedObject.keys(f)[0];
+      f = castTo(f[key]);
       keys.push(key);
     }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const rf = f as unknown as (number | boolean);
+    const rf: number | boolean = castTo(f);
     return {
       [keys.join('.')]: typeof rf === 'boolean' ? (rf ? 1 : 0) : rf
     };
   }
 
   static uuid(val: string): Binary {
-    return new Binary(Buffer.from(val.replace(/-/g, ''), 'hex'), Binary.SUBTYPE_UUID);
+    return new Binary(Buffer.from(val.replaceAll('-', ''), 'hex'), Binary.SUBTYPE_UUID);
   }
 
   static idToString(id: string | ObjectId | Binary): string {
@@ -64,87 +62,45 @@ export class MongoUtil {
 
   static preInsertId<T extends ModelType>(item: T): T {
     if (item && item.id) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const itemWithId = item as WithId<T>;
+      const itemWithId: WithId<T> = castTo(item);
       itemWithId._id = this.uuid(item.id);
     }
     return item;
   }
 
-  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(cls, q.where) : {}
-    };
+  static extractWhereFilter<T extends ModelType, U extends WhereClause<T>>(cls: Class<T>, where?: U, checkExpiry = true): Record<string, unknown> {
+    where = castTo(ModelQueryUtil.getWhereClause(cls, where, checkExpiry));
+    return where ? this.extractWhereClause(cls, where) : {};
   }
 
-  // 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);
-
   /**
    * Build mongo where clause
    */
   static extractWhereClause<T>(cls: Class<T>, o: WhereClause<T>): Record<string, unknown> {
-    if (this.has$And(o)) {
+    if (ModelQueryUtil.has$And(o)) {
       return { $and: o.$and.map(x => this.extractWhereClause<T>(cls, x)) };
-    } else if (this.has$Or(o)) {
+    } else if (ModelQueryUtil.has$Or(o)) {
       return { $or: o.$or.map(x => this.extractWhereClause<T>(cls, x)) };
-    } else if (this.has$Not(o)) {
+    } else if (ModelQueryUtil.has$Not(o)) {
       return { $nor: [this.extractWhereClause<T>(cls, o.$not)] };
     } else {
       return this.extractSimple(cls, o);
     }
   }
 
-  /**
-   * Convert ids from '_id' to 'id'
-   */
-  static replaceId(v: Record<string, unknown>): Record<string, Binary>;
-  static replaceId(v: string[]): Binary[];
-  static replaceId(v: string): Binary;
-  static replaceId(v: unknown): undefined;
-  static replaceId(v: string | string[] | Record<string, unknown> | unknown): unknown {
-    if (typeof v === 'string') {
-      return this.uuid(v);
-    } else if (Array.isArray(v)) {
-      return v.map(x => this.replaceId(x));
-    } else if (DataUtil.isPlainObject(v)) {
-      const out: Record<string, Binary> = {};
-      for (const [k, el] of Object.entries(v)) {
-        const found = this.replaceId(el);
-        if (found) {
-          out[k] = found;
-        }
-      }
-      return out;
-    } else {
-      return v;
-    }
-  }
-
   /**/
   static extractSimple<T>(base: Class<T> | undefined, o: Record<string, unknown>, path: string = '', recursive: boolean = true): Record<string, unknown> {
     const schema = base ? SchemaRegistry.get(base) : undefined;
     const out: Record<string, unknown> = {};
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const sub = o as Record<string, unknown>;
+    const sub = o;
     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>;
+      const v: Record<string, unknown> = castTo(sub[key]);
       const subField = schema?.views[AllViewⲐ].schema[key];
 
       if (subpath === 'id') { // Handle ids directly
-        out._id = this.replaceId(v);
+        out._id = typeof v === 'string' ? this.uuid(v) : v;
       } else {
         const isPlain = v && DataUtil.isPlainObject(v);
         const firstKey = isPlain ? Object.keys(v)[0] : '';
@@ -170,18 +126,14 @@ export class MongoUtil {
               v.$nin = [null, []];
             }
           } else if (firstKey === '$regex') {
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            v.$regex = DataUtil.toRegex(v.$regex as string | RegExp);
+            v.$regex = DataUtil.toRegex(castTo(v.$regex));
           } 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')];
+            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) {
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            const coords = v.$geoWithin as [number, number][];
+            const coords: [number, number][] = castTo(v.$geoWithin);
             const first = coords[0];
             const last = coords[coords.length - 1];
             // Connect if not

package/src/service.ts

@@ -1,7 +1,8 @@
 // Wildcard import needed here due to packaging issues
 import {
   type Db, GridFSBucket, MongoClient, type Sort, type CreateIndexesOptions,
-  type GridFSFile, type IndexSpecification, type Collection, type ObjectId, type Filter, type Document
+  type GridFSFile, type IndexSpecification, type Collection, ObjectId,
+  Binary
 } from 'mongodb';
 import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
@@ -16,12 +17,13 @@ import {
 } from '@travetto/model';
 import {
   ModelQuery, ModelQueryCrudSupport, ModelQueryFacetSupport, ModelQuerySupport,
-  PageableModelQuery, ValidStringFields, WhereClause, ModelQuerySuggestSupport
+  PageableModelQuery, ValidStringFields, WhereClause, ModelQuerySuggestSupport,
+  QueryVerifier
 } from '@travetto/model-query';
 
-import { ShutdownManager, type Class, AppError, TypedObject } from '@travetto/base';
+import { ShutdownManager, type Class, type DeepPartial, AppError, TypedObject, castTo, asFull } from '@travetto/runtime';
 import { Injectable } from '@travetto/di';
-import { DeepPartial, FieldConfig, SchemaRegistry, SchemaValidator } from '@travetto/schema';
+import { FieldConfig, SchemaRegistry, SchemaValidator } from '@travetto/schema';
 
 import { ModelCrudUtil } from '@travetto/model/src/internal/service/crud';
 import { ModelIndexedUtil } from '@travetto/model/src/internal/service/indexed';
@@ -40,8 +42,7 @@ import { MongoModelConfig } from './config';
 
 const IdxFieldsⲐ = Symbol.for('@travetto/model-mongo:idx');
 
-// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-const asFielded = <T extends ModelType>(cfg: IndexConfig<T>): { [IdxFieldsⲐ]: Sort } => (cfg as unknown as { [IdxFieldsⲐ]: Sort });
+const asFielded = (cfg: IndexConfig<ModelType>): { [IdxFieldsⲐ]: Sort } => castTo(cfg);
 
 type IdxCfg = CreateIndexesOptions;
 
@@ -66,8 +67,7 @@ export class MongoModelService implements
   constructor(public readonly config: MongoModelConfig) { }
 
   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[];
+    const files: StreamRaw[] = castTo(await this.#bucket.find({ filename: location }, { limit: 1 }).toArray());
 
     if (!files?.length) {
       throw new NotFoundError(STREAMS, location);
@@ -88,8 +88,8 @@ export class MongoModelService implements
     ModelExpiryUtil.registerCull(this);
   }
 
-  getWhere<T extends ModelType>(cls: Class<T>, where: WhereClause<T>, checkExpiry = true): Record<string, unknown> {
-    return MongoUtil.prepareQuery(cls, { where }, checkExpiry).filter;
+  getWhereFilter<T extends ModelType>(cls: Class<T>, where: WhereClause<T>, checkExpiry = true): Record<string, unknown> {
+    return MongoUtil.extractWhereFilter(cls, where, checkExpiry);
   }
 
   // Storage
@@ -117,14 +117,13 @@ export class MongoModelService implements
     return out;
   }
 
-  getIndicies<T extends ModelType>(cls: Class<T>): ([IndexSpecification] | [IndexSpecification, IdxCfg])[] {
+  getIndices<T extends ModelType>(cls: Class<T>): ([IndexSpecification] | [IndexSpecification, IdxCfg])[] {
     const indices = ModelRegistry.get(cls).indices ?? [];
     return [
       ...indices.map((idx): [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 IndexSpecification,
+          castTo(combined),
           (idx.type === 'unique' ? { unique: true } : {})
         ];
       }),
@@ -134,7 +133,7 @@ export class MongoModelService implements
 
   async establishIndices<T extends ModelType>(cls: Class<T>): Promise<void> {
     const col = await this.getStore(cls);
-    const creating = this.getIndicies(cls);
+    const creating = this.getIndices(cls);
     if (creating.length) {
       console.debug('Creating indexes', { indices: creating });
       for (const el of creating) {
@@ -172,7 +171,7 @@ export class MongoModelService implements
   // Crud
   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 }), {});
+    const result = await store.findOne(this.getWhereFilter<ModelType>(cls, { id }), {});
     if (result) {
       const res = await ModelCrudUtil.load(cls, result);
       if (res) {
@@ -183,24 +182,22 @@ export class MongoModelService implements
   }
 
   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 cleaned: WithId<T, Binary> = castTo(await ModelCrudUtil.preStore(cls, item, this));
+    cleaned._id = MongoUtil.uuid(cleaned.id);
 
     const store = await this.getStore(cls);
-    const result = await store.insertOne(cleaned);
+    const result = await store.insertOne(castTo(cleaned));
     if (!result.insertedId) {
       throw new ExistsError(cls, cleaned.id);
     }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    delete (cleaned as { _id?: unknown })._id;
+    delete cleaned._id;
     return cleaned;
   }
 
   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);
+    const res = await store.replaceOne(this.getWhereFilter<ModelType>(cls, { id: item.id }), item);
     if (res.matchedCount === 0) {
       throw new NotFoundError(cls, item.id);
     }
@@ -212,7 +209,7 @@ export class MongoModelService implements
     const store = await this.getStore(cls);
     try {
       await store.updateOne(
-        this.getWhere<ModelType>(cls, { id: cleaned.id }, false),
+        this.getWhereFilter<ModelType>(cls, { id: cleaned.id }, false),
         { $set: cleaned },
         { upsert: true }
       );
@@ -240,15 +237,11 @@ export class MongoModelService implements
     const items = MongoUtil.extractSimple(cls, final, undefined, false);
     final = Object
       .entries(items)
-      .reduce<Record<string, unknown>>((acc, [k, v]) => {
+      .reduce<Partial<Record<'$unset' | '$set', Record<string, unknown>>>>((acc, [k, v]) => {
         if (v === null || v === undefined) {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          const o = (acc.$unset ??= {}) as Record<string, unknown>;
-          o[k] = v;
+          (acc.$unset ??= {})[k] = v;
         } else {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          const o = (acc.$set ??= {}) as Record<string, unknown>;
-          o[k] = v;
+          (acc.$set ??= {})[k] = v;
         }
         return acc;
       }, {});
@@ -256,7 +249,7 @@ export class MongoModelService implements
     const id = item.id;
 
     const res = await store.findOneAndUpdate(
-      this.getWhere<ModelType>(cls, { id }),
+      this.getWhereFilter<ModelType>(cls, { id }),
       final,
       { returnDocument: 'after', includeResultMetadata: true }
     );
@@ -270,7 +263,7 @@ export class MongoModelService implements
 
   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));
+    const result = await store.deleteOne(this.getWhereFilter<ModelType>(cls, { id }, false));
     if (result.deletedCount === 0) {
       throw new NotFoundError(cls, id);
     }
@@ -278,7 +271,7 @@ 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.getWhere(cls, {}), { timeout: true }).batchSize(100);
+    const cursor = store.find(this.getWhereFilter(cls, {}), { timeout: true }).batchSize(100);
     for await (const el of cursor) {
       try {
         yield MongoUtil.postLoadId(await ModelCrudUtil.load(cls, el));
@@ -350,8 +343,7 @@ export class MongoModelService implements
 
     for (const op of operations) {
       if (op.insert) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        bulk.insert(MongoUtil.preInsertId(op.insert as T));
+        bulk.insert(MongoUtil.preInsertId(asFull(op.insert)));
       } else if (op.upsert) {
         bulk.find({ _id: MongoUtil.uuid(op.upsert.id!) }).upsert().updateOne({ $set: op.upsert });
       } else if (op.update) {
@@ -365,13 +357,11 @@ export class MongoModelService implements
 
     for (const op of operations) {
       if (op.insert) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        MongoUtil.postLoadId(op.insert as T);
+        MongoUtil.postLoadId(asFull(op.insert));
       }
     }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    for (const [index, _id] of TypedObject.entries(res.upsertedIds) as [number, ObjectId][]) {
-      out.insertedIds.set(+index, MongoUtil.idToString(_id));
+    for (const [index, _id] of TypedObject.entries(res.upsertedIds)) {
+      out.insertedIds.set(+index, MongoUtil.idToString(castTo(_id)));
     }
 
     if (out.counts) {
@@ -385,8 +375,7 @@ export class MongoModelService implements
       out.errors = res.getWriteErrors();
       for (const err of out.errors) {
         const op = operations[err.index];
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const k = Object.keys(op)[0] as keyof BulkResponse['counts'];
+        const k = TypedObject.keys(op)[0];
         out.counts[k] -= 1;
       }
       out.counts.error = out.errors.length;
@@ -405,10 +394,9 @@ export class MongoModelService implements
     const { key } = ModelIndexedUtil.computeIndexKey(cls, idx, body);
     const store = await this.getStore(cls);
     const result = await store.findOne(
-      this.getWhere(
+      this.getWhereFilter(
         cls,
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        ModelIndexedUtil.projectIndex(cls, idx, body) as WhereClause<T>
+        castTo(ModelIndexedUtil.projectIndex(cls, idx, body))
       )
     );
     if (!result) {
@@ -421,10 +409,9 @@ export class MongoModelService implements
     const { key } = ModelIndexedUtil.computeIndexKey(cls, idx, body);
     const store = await this.getStore(cls);
     const result = await store.deleteOne(
-      this.getWhere(
+      this.getWhereFilter(
         cls,
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        ModelIndexedUtil.projectIndex(cls, idx, body) as WhereClause<T>
+        castTo(ModelIndexedUtil.projectIndex(cls, idx, body))
       )
     );
     if (result.deletedCount) {
@@ -445,25 +432,24 @@ export class MongoModelService implements
       throw new AppError('Cannot list on unique indices', 'data');
     }
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const where = this.getWhere(
+    const where = this.getWhereFilter(
       cls,
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      ModelIndexedUtil.projectIndex(cls, idx, body, { emptySortValue: { $exists: true } }) as WhereClause<T>
-    ) as Filter<Document>;
+      castTo(ModelIndexedUtil.projectIndex(cls, idx, body, { emptySortValue: { $exists: true } }))
+    );
 
     const cursor = store.find(where, { timeout: true }).batchSize(100).sort(asFielded(idxCfg)[IdxFieldsⲐ]);
 
     for await (const el of cursor) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      yield (await MongoUtil.postLoadId(await ModelCrudUtil.load(cls, el))) as T;
+      yield (await MongoUtil.postLoadId(await ModelCrudUtil.load(cls, el)));
     }
   }
 
   // Query
   async query<T extends ModelType>(cls: Class<T>, query: PageableModelQuery<T>): Promise<T[]> {
+    await QueryVerifier.verify(cls, query);
+
     const col = await this.getStore(cls);
-    const { filter } = MongoUtil.prepareQuery(cls, query);
+    const filter = MongoUtil.extractWhereFilter(cls, query.where);
     let cursor = col.find<T>(filter, {});
     if (query.select) {
       const selectKey = Object.keys(query.select)[0];
@@ -493,8 +479,10 @@ export class MongoModelService implements
   }
 
   async queryCount<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number> {
+    await QueryVerifier.verify(cls, query);
+
     const col = await this.getStore(cls);
-    const { filter } = MongoUtil.prepareQuery(cls, query);
+    const filter = MongoUtil.extractWhereFilter(cls, query.where);
     return col.countDocuments(filter);
   }
 
@@ -505,11 +493,14 @@ export class MongoModelService implements
 
   // Query Crud
   async updateOneWithQuery<T extends ModelType>(cls: Class<T>, data: T, query: ModelQuery<T>): Promise<T> {
+    await QueryVerifier.verify(cls, query);
+
     const col = await this.getStore(cls);
     const item = await ModelCrudUtil.preStore(cls, data, this);
-    query = ModelQueryUtil.getQueryWithId(cls, data, query);
+    const where = ModelQueryUtil.getWhereClause(cls, query.where);
+    where.id = item.id;
 
-    const { filter } = MongoUtil.prepareQuery(cls, query);
+    const filter = MongoUtil.extractWhereFilter(cls, where);
     const res = await col.replaceOne(filter, item);
     if (res.matchedCount === 0) {
       throw new NotFoundError(cls, item.id);
@@ -518,57 +509,62 @@ export class MongoModelService implements
   }
 
   async deleteByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number> {
+    await QueryVerifier.verify(cls, query);
+
     const col = await this.getStore(cls);
-    const { filter } = MongoUtil.prepareQuery(cls, query, false);
+    const filter = MongoUtil.extractWhereFilter(cls, query.where, false);
     const res = await col.deleteMany(filter);
     return res.deletedCount ?? 0;
   }
 
   async updateByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>, data: Partial<T>): Promise<number> {
-    const col = await this.getStore(cls);
+    await QueryVerifier.verify(cls, query);
 
+    const col = await this.getStore(cls);
     const items = MongoUtil.extractSimple(cls, data);
-    const final = Object.entries(items).reduce<Record<string, unknown>>((acc, [k, v]) => {
-      if (v === null || v === undefined) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const o = (acc.$unset = acc.$unset ?? {}) as Record<string, unknown>;
-        o[k] = v;
-      } else {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const o = (acc.$set = acc.$set ?? {}) as Record<string, unknown>;
-        o[k] = v;
-      }
-      return acc;
-    }, {});
+    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;
+        } else {
+          (acc.$set ??= {})[k] = v;
+        }
+        return acc;
+      }, {});
 
-    const { filter } = MongoUtil.prepareQuery(cls, query);
+    const filter = MongoUtil.extractWhereFilter(cls, query.where);
     const res = await col.updateMany(filter, final);
     return res.matchedCount;
   }
 
   // Facet
   async facet<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, query?: ModelQuery<T>): Promise<{ key: string, count: number }[]> {
+    await QueryVerifier.verify(cls, query);
+
     const col = await this.getStore(cls);
-    const aggs: object[] = [{
-      $group: {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        _id: `$${field as string}`,
-        count: {
-          $sum: 1
-        }
-      }
-    }];
+    if (query) {
+      await QueryVerifier.verify(cls, query);
+    }
 
     let q: Record<string, unknown> = { [field]: { $exists: true } };
 
     if (query?.where) {
-      q = { $and: [q, MongoUtil.prepareQuery(cls, query).filter] };
+      q = { $and: [q, MongoUtil.extractWhereFilter(cls, query.where)] };
     }
 
-    aggs.unshift({ $match: q });
+    const aggregations: object[] = [
+      { $match: q },
+      {
+        $group: {
+          _id: `$${field}`,
+          count: {
+            $sum: 1
+          }
+        }
+      }
+    ];
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const result = (await col.aggregate(aggs).toArray()) as { _id: ObjectId, count: number }[];
+    const result = await col.aggregate<{ _id: ObjectId, count: number }>(aggregations).toArray();
 
     return result.map(val => ({
       key: MongoUtil.idToString(val._id),
@@ -578,12 +574,14 @@ 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);
     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);
     return ModelQuerySuggestUtil.combineSuggestResults(cls, field, prefix, results, (_, b) => b, query && query.limit);