@travetto/model-mongo 5.0.0-rc.8 → 5.0.0

package/README.md

@@ -17,10 +17,10 @@ This module provides an [mongodb](https://mongodb.com)-based implementation for
 
 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#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#L19)
    *  [Indexed](https://github.com/travetto/travetto/tree/main/module/model/src/service/indexed.ts#L12)
+   *  [Blob](https://github.com/travetto/travetto/tree/main/module/model/src/service/blob.ts#L8)
    *  [Query Crud](https://github.com/travetto/travetto/tree/main/module/model-query/src/service/crud.ts#L11)
    *  [Facet](https://github.com/travetto/travetto/tree/main/module/model-query/src/service/facet.ts#L12)
    *  [Query](https://github.com/travetto/travetto/tree/main/module/model-query/src/service/query.ts#L10)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-mongo",
-  "version": "5.0.0-rc.8",
+  "version": "5.0.0",
   "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.8",
-    "@travetto/model": "^5.0.0-rc.8",
-    "@travetto/model-query": "^5.0.0-rc.8",
+    "@travetto/config": "^5.0.0",
+    "@travetto/model": "^5.0.0",
+    "@travetto/model-query": "^5.0.0",
     "mongodb": "^6.8.0"
   },
   "peerDependencies": {
-    "@travetto/command": "^5.0.0-rc.8"
+    "@travetto/command": "^5.0.0"
   },
   "peerDependenciesMeta": {
     "@travetto/command": {

package/src/internal/util.ts

@@ -1,7 +1,7 @@
 import { Binary, ObjectId } from 'mongodb';
 
-import { Class } from '@travetto/runtime';
-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,25 +1,26 @@
-// 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';
+import { Readable } from 'node:stream';
 
 import {
-  ModelRegistry, ModelType, OptionalId,
-  ModelCrudSupport, ModelStorageSupport, ModelStreamSupport,
-  ModelExpirySupport, ModelBulkSupport, ModelIndexedSupport,
-  StreamMeta, BulkOp, BulkResponse,
-  NotFoundError, ExistsError, IndexConfig,
-  StreamRange
+  ModelRegistry, ModelType, OptionalId, ModelCrudSupport, ModelStorageSupport,
+  ModelExpirySupport, ModelBulkSupport, ModelIndexedSupport, BulkOp, BulkResponse,
+  NotFoundError, ExistsError, IndexConfig, ModelBlobSupport
 } 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, type DeepPartial, AppError, TypedObject } from '@travetto/runtime';
+import {
+  ShutdownManager, type Class, type DeepPartial, AppError, TypedObject,
+  castTo, asFull, BlobMeta, ByteRange, BinaryInput, BinaryUtil
+} from '@travetto/runtime';
 import { Injectable } from '@travetto/di';
 import { FieldConfig, SchemaRegistry, SchemaValidator } from '@travetto/schema';
 
@@ -31,21 +32,20 @@ import { ModelQuerySuggestUtil } from '@travetto/model-query/src/internal/servic
 import { PointImpl } from '@travetto/model-query/src/internal/model/point';
 import { ModelQueryExpiryUtil } from '@travetto/model-query/src/internal/service/expiry';
 import { ModelExpiryUtil } from '@travetto/model/src/internal/service/expiry';
-import { enforceRange, StreamModel, STREAMS } from '@travetto/model/src/internal/service/stream';
 import { AllViewⲐ } from '@travetto/schema/src/internal/types';
 import { ModelBulkUtil } from '@travetto/model/src/internal/service/bulk';
+import { MODEL_BLOB, ModelBlobNamespace, ModelBlobUtil } from '@travetto/model/src/internal/service/blob';
 
 import { MongoUtil, WithId } from './internal/util';
 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;
 
-type StreamRaw = GridFSFile & { metadata: StreamMeta };
+type BlobRaw = GridFSFile & { metadata?: BlobMeta };
 
 /**
  * Mongo-based model source
@@ -53,7 +53,7 @@ type StreamRaw = GridFSFile & { metadata: StreamMeta };
 @Injectable()
 export class MongoModelService implements
   ModelCrudSupport, ModelStorageSupport,
-  ModelBulkSupport, ModelStreamSupport,
+  ModelBulkSupport, ModelBlobSupport,
   ModelIndexedSupport, ModelQuerySupport,
   ModelQueryCrudSupport, ModelQueryFacetSupport,
   ModelQuerySuggestSupport, ModelExpirySupport {
@@ -65,12 +65,11 @@ 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[];
+  async #describeBlobRaw(location: string): Promise<BlobRaw> {
+    const files: BlobRaw[] = await this.#bucket.find({ filename: location }, { limit: 1 }).toArray();
 
     if (!files?.length) {
-      throw new NotFoundError(STREAMS, location);
+      throw new NotFoundError(ModelBlobNamespace, location);
     }
 
     return files[0];
@@ -80,7 +79,7 @@ export class MongoModelService implements
     this.client = await MongoClient.connect(this.config.url, this.config.options);
     this.#db = this.client.db(this.config.namespace);
     this.#bucket = new GridFSBucket(this.#db, {
-      bucketName: STREAMS,
+      bucketName: ModelBlobNamespace,
       writeConcern: { w: 1 }
     });
     await ModelStorageUtil.registerModelChangeListener(this);
@@ -88,8 +87,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 +116,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 +132,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) {
@@ -152,10 +150,8 @@ export class MongoModelService implements
   }
 
   async truncateModel<T extends ModelType>(cls: Class<T>): Promise<void> {
-    if (cls === StreamModel) {
-      try {
-        await this.#bucket.drop();
-      } catch { }
+    if (cls === MODEL_BLOB) {
+      await this.#bucket.drop().catch(() => { });
     } else {
       const col = await this.getStore(cls);
       await col.deleteMany({});
@@ -172,7 +168,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 +179,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 +206,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 +234,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 +246,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 +260,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 +268,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));
@@ -290,37 +280,39 @@ export class MongoModelService implements
     }
   }
 
-  // Stream
-  async upsertStream(location: string, input: Readable, meta: StreamMeta): Promise<void> {
+  // Blob
+  async upsertBlob(location: string, input: BinaryInput, meta?: BlobMeta, overwrite = true): Promise<void> {
+    const existing = await this.describeBlob(location).then(() => true, () => false);
+    if (!overwrite && existing) {
+      return;
+    }
+    const [stream, blobMeta] = await ModelBlobUtil.getInput(input, meta);
     const writeStream = this.#bucket.openUploadStream(location, {
-      contentType: meta.contentType,
-      metadata: meta
+      contentType: blobMeta.contentType,
+      metadata: blobMeta,
     });
+    await pipeline(stream, writeStream);
 
-    await pipeline(input, writeStream);
-  }
-
-  async getStream(location: string, range?: StreamRange): Promise<Readable> {
-    const meta = await this.describeStream(location);
-
-    if (range) {
-      range = enforceRange(range, meta.size);
-      range.end! += 1; // range is exclusive
+    if (existing) {
+      const [read] = await this.#bucket.find({ filename: location, _id: { $ne: writeStream.id } }).toArray();
+      await this.#bucket.delete(read._id);
     }
+  }
 
-    const res = await this.#bucket.openDownloadStreamByName(location, range);
-    if (!res) {
-      throw new NotFoundError(STREAMS, location);
-    }
-    return res;
+  async getBlob(location: string, range?: ByteRange): Promise<Blob> {
+    const meta = await this.describeBlob(location);
+    const final = range ? ModelBlobUtil.enforceRange(range, meta.size!) : undefined;
+    const mongoRange = final ? { start: final.start, end: final.end + 1 } : undefined;
+    const res = (): Readable => this.#bucket.openDownloadStreamByName(location, mongoRange);
+    return BinaryUtil.readableBlob(res, { ...meta, range: final });
   }
 
-  async describeStream(location: string): Promise<StreamMeta> {
-    return (await this.#describeStreamRaw(location)).metadata;
+  async describeBlob(location: string): Promise<BlobMeta> {
+    return (await this.#describeBlobRaw(location)).metadata ?? {};
   }
 
-  async deleteStream(location: string): Promise<void> {
-    const fileId = (await this.#describeStreamRaw(location))._id;
+  async deleteBlob(location: string): Promise<void> {
+    const fileId = (await this.#describeBlobRaw(location))._id;
     await this.#bucket.delete(fileId);
   }
 
@@ -350,8 +342,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 +356,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 +374,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 +393,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 +408,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 +431,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 +478,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 +492,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 +508,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 +573,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);