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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-sql",
-  "version": "5.0.0-rc.1",
+  "version": "5.0.0-rc.10",
   "description": "SQL backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
     "sql",
@@ -27,14 +27,14 @@
     "directory": "module/model-sql"
   },
   "dependencies": {
-    "@travetto/config": "^5.0.0-rc.1",
-    "@travetto/context": "^5.0.0-rc.1",
-    "@travetto/model": "^5.0.0-rc.1",
-    "@travetto/model-query": "^5.0.0-rc.1"
+    "@travetto/config": "^5.0.0-rc.10",
+    "@travetto/context": "^5.0.0-rc.9",
+    "@travetto/model": "^5.0.0-rc.10",
+    "@travetto/model-query": "^5.0.0-rc.10"
   },
   "peerDependencies": {
-    "@travetto/command": "^5.0.0-rc.1",
-    "@travetto/test": "^5.0.0-rc.1"
+    "@travetto/command": "^5.0.0-rc.9",
+    "@travetto/test": "^5.0.0-rc.9"
   },
   "peerDependenciesMeta": {
     "@travetto/command": {

package/src/config.ts

@@ -1,4 +1,5 @@
 import { Config } from '@travetto/config';
+import { asFull } from '@travetto/runtime';
 
 /**
  * SQL Model Config
@@ -40,6 +41,5 @@ export class SQLModelConfig<T extends {} = {}> {
   /**
    * Raw client options
    */
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  options: T = {} as T;
+  options: T = asFull({});
 }

package/src/connection/base.ts

@@ -1,4 +1,4 @@
-import { Util } from '@travetto/base';
+import { castTo, Util } from '@travetto/runtime';
 import { AsyncContext } from '@travetto/context';
 
 const ContextActiveⲐ: unique symbol = Symbol.for('@travetto/model:sql-active');
@@ -95,13 +95,12 @@ export abstract class Connection<C = unknown> {
    * @param op
    * @param args
    */
-  async * iterateWithActive<R>(op: () => AsyncGenerator<R>): AsyncIterable<R> {
+  async * iterateWithActive<R>(op: () => AsyncIterable<R>): AsyncIterable<R> {
     if (this.active) {
       yield* op();
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this;
+    const self = castTo<Connection>(this);
     yield* this.context.iterate(async function* () {
       try {
         self.context.set(ContextActiveⲐ, await self.acquire());
@@ -117,7 +116,7 @@ export abstract class Connection<C = unknown> {
   /**
    * Run a function within a valid sql transaction.  Relies on @travetto/context.
    */
-  async runWithTransaction<R>(mode: TransactionType, op: () => R): Promise<R> {
+  async runWithTransaction<R>(mode: TransactionType, op: () => Promise<R>): Promise<R> {
     if (this.activeTx) {
       if (mode === 'isolated' || mode === 'force') {
         const txId = mode === 'isolated' ? `tx${Util.uuid()}` : undefined;

package/src/connection/decorator.ts

@@ -1,3 +1,4 @@
+import { AsyncItrMethodDescriptor, AsyncMethodDescriptor } from '@travetto/runtime';
 import { Connection, TransactionType } from './base';
 
 /**
@@ -10,38 +11,41 @@ export interface ConnectionAware<C = unknown> {
 /**
  * Decorator to ensure a method runs with a valid connection
  */
-export function Connected<T extends ConnectionAware>() {
-  return function (target: T, prop: string | symbol, desc: TypedPropertyDescriptor<(...params: unknown[]) => Promise<unknown>>): void {
+export function Connected() {
+  return function <T extends { conn?: Connection }>(
+    target: T, prop: string | symbol, desc: AsyncMethodDescriptor<T>
+  ): void {
     const og = desc.value!;
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    desc.value = async function (this: T, ...args: unknown[]) {
-      return this.conn.runWithActive(() => og.call(this, ...args));
-    } as typeof og;
+    desc.value = function (...args: unknown[]): ReturnType<typeof og> {
+      return this.conn!.runWithActive(() => og.call(this, ...args));
+    };
   };
 }
 
 /**
  * Decorator to ensure a method runs with a valid connection
  */
-export function ConnectedIterator<T extends ConnectionAware>() {
-  return function (target: T, prop: string | symbol, desc: TypedPropertyDescriptor<(...params: unknown[]) => AsyncGenerator<unknown>>): void {
+export function ConnectedIterator() {
+  return function <T extends { conn?: Connection }>(
+    target: T, prop: string | symbol, desc: AsyncItrMethodDescriptor<T>
+  ): void {
     const og = desc.value!;
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    desc.value = async function* (this: T, ...args: unknown[]) {
-      yield* this.conn.iterateWithActive(() => og.call(this, ...args));
-    } as typeof og;
+    desc.value = async function* (...args: unknown[]): ReturnType<typeof og> {
+      yield* this.conn!.iterateWithActive(() => og.call(this, ...args));
+    };
   };
 }
 
 /**
  * Decorator to ensure a method runs with a valid transaction
  */
-export function Transactional<T extends ConnectionAware>(mode: TransactionType = 'required') {
-  return function (target: T, prop: string | symbol, desc: TypedPropertyDescriptor<(...params: unknown[]) => Promise<unknown>>): void {
+export function Transactional(mode: TransactionType = 'required') {
+  return function <T extends { conn?: Connection }>(
+    target: unknown, prop: string | symbol, desc: AsyncMethodDescriptor<T>
+  ): void {
     const og = desc.value!;
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    desc.value = function (this: T, ...args: unknown[]) {
-      return this.conn.runWithTransaction(mode, () => og.call(this, ...args));
-    } as typeof og;
+    desc.value = function (...args: unknown[]): ReturnType<typeof og> {
+      return this.conn!.runWithTransaction(mode, () => og.call(this, ...args));
+    };
   };
-}
+}

package/src/dialect/base.ts

@@ -1,6 +1,6 @@
-import { RuntimeIndex } from '@travetto/manifest';
+/* eslint-disable @stylistic/indent */
 import { DataUtil, SchemaRegistry, FieldConfig, Schema } from '@travetto/schema';
-import { Class, AppError, TypedObject } from '@travetto/base';
+import { Class, AppError, TypedObject, describeFunction, TimeUtil, castTo, castKey } from '@travetto/runtime';
 import { SelectClause, Query, SortClause, WhereClause, RetainFields } from '@travetto/model-query';
 import { BulkResponse, IndexConfig } from '@travetto/model';
 import { PointImpl } from '@travetto/model-query/src/internal/model/point';
@@ -11,13 +11,6 @@ import { SQLUtil, VisitStack } from '../internal/util';
 import { DeleteWrapper, InsertWrapper, DialectState } from '../internal/types';
 import { Connection } from '../connection/base';
 
-// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-const has$And = (o: unknown): o is ({ $and: WhereClause<unknown>[] }) => !!o && '$and' in (o as object);
-// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-const has$Or = (o: unknown): o is ({ $or: WhereClause<unknown>[] }) => !!o && '$or' in (o as object);
-// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-const has$Not = (o: unknown): o is ({ $not: WhereClause<unknown> }) => !!o && '$not' in (o as object);
-
 interface Alias {
   alias: string;
   path: VisitStack[];
@@ -196,16 +189,18 @@ export abstract class SQLDialect implements DialectState {
         const src = DataUtil.toRegex(value).source.replace(/\\b/g, this.regexWordBoundary);
         return this.quote(src);
       } else {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        return this.quote(value as string);
+        return this.quote(castTo(value));
       }
     } else if (conf.type === Boolean) {
       return `${value ? 'TRUE' : 'FALSE'}`;
     } else if (conf.type === Number) {
       return `${value}`;
     } else if (conf.type === Date) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return this.resolveDateValue(ModelQueryUtil.resolveComparator(value) as Date);
+      if (typeof value === 'string' && TimeUtil.isTimeSpan(value)) {
+        return this.resolveDateValue(TimeUtil.fromNow(value));
+      } else {
+        return this.resolveDateValue(DataUtil.coerceType(value, Date, true));
+      }
     } else if (conf.type === PointImpl && Array.isArray(value)) {
       return `point(${value[0]},${value[1]})`;
     } else if (conf.type === Object) {
@@ -276,8 +271,7 @@ export abstract class SQLDialect implements DialectState {
    * Delete query and return count removed
    */
   async deleteAndGetCount<T>(cls: Class<T>, query: Query<T>): Promise<number> {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const { count } = await this.executeSQL(this.getDeleteSQL(SQLUtil.classToStack(cls), query.where as WhereClause<T>));
+    const { count } = await this.executeSQL<T>(this.getDeleteSQL(SQLUtil.classToStack(cls), query.where));
     return count;
   }
 
@@ -285,7 +279,7 @@ export abstract class SQLDialect implements DialectState {
    * Get the count for a given query
    */
   async getCountForQuery<T>(cls: Class<T>, query: Query<T>): Promise<number> {
-    const { records } = await this.executeSQL<{ total: number }>(this.getQueryCountSQL(cls, query));
+    const { records } = await this.executeSQL<{ total: number }>(this.getQueryCountSQL(cls, query.where));
     const [record] = records;
     return Total.from(record).total;
   }
@@ -302,9 +296,8 @@ export abstract class SQLDialect implements DialectState {
    * Add a sql column
    */
   getAddColumnSQL(stack: VisitStack[]): string {
-    const field = stack[stack.length - 1];
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return `ALTER TABLE ${this.parentTable(stack)} ADD COLUMN ${this.getColumnDefinition(field as FieldConfig)};`;
+    const field: FieldConfig = castTo(stack[stack.length - 1]);
+    return `ALTER TABLE ${this.parentTable(stack)} ADD COLUMN ${this.getColumnDefinition(field)};`;
   }
 
   /**
@@ -456,8 +449,7 @@ export abstract class SQLDialect implements DialectState {
               break;
             }
             case '$regex': {
-              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-              const re = DataUtil.toRegex(v as string);
+              const re = DataUtil.toRegex(castTo(v));
               const src = re.source;
               const ins = re.flags && re.flags.includes('i');
 
@@ -506,8 +498,7 @@ export abstract class SQLDialect implements DialectState {
               break;
             }
             case '$lt': case '$gt': case '$gte': case '$lte': {
-              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-              const subItems = TypedObject.keys(top as typeof SQL_OPS)
+              const subItems = TypedObject.keys(castTo<typeof SQL_OPS>(top))
                 .map(ssk => `${sPath} ${SQL_OPS[ssk]} ${resolve(top[ssk])}`);
               items.push(subItems.length > 1 ? `(${subItems.join(` ${SQL_OPS.$and} `)})` : subItems[0]);
               break;
@@ -537,11 +528,11 @@ export abstract class SQLDialect implements DialectState {
   getWhereGroupingSQL<T>(cls: Class<T>, o: WhereClause<T>): string {
     const SQL_OPS = this.SQL_OPS;
 
-    if (has$And(o)) {
+    if (ModelQueryUtil.has$And(o)) {
       return `(${o.$and.map(x => this.getWhereGroupingSQL<T>(cls, x)).join(` ${SQL_OPS.$and} `)})`;
-    } else if (has$Or(o)) {
+    } else if (ModelQueryUtil.has$Or(o)) {
       return `(${o.$or.map(x => this.getWhereGroupingSQL<T>(cls, x)).join(` ${SQL_OPS.$or} `)})`;
-    } else if (has$Not(o)) {
+    } else if (ModelQueryUtil.has$Not(o)) {
       return `${SQL_OPS.$not} (${this.getWhereGroupingSQL<T>(cls, o.$not)})`;
     } else {
       return this.getWhereFieldSQL(SQLUtil.classToStack(cls), o);
@@ -554,8 +545,7 @@ export abstract class SQLDialect implements DialectState {
   getWhereSQL<T>(cls: Class<T>, where?: WhereClause<T>): string {
     return !where || !Object.keys(where).length ?
       '' :
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      `WHERE ${this.getWhereGroupingSQL(cls, where as WhereClause<T>)}`;
+      `WHERE ${this.getWhereGroupingSQL(cls, castTo(where))}`;
   }
 
   /**
@@ -624,15 +614,13 @@ LEFT OUTER JOIN ${from} ON
   /**
    * Generate full query
    */
-  getQuerySQL<T>(cls: Class<T>, query: Query<T>): string {
+  getQuerySQL<T>(cls: Class<T>, query: Query<T>, where?: WhereClause<T>): string {
     const sortFields = !query.sort ?
       '' :
       SQLUtil.orderBy(cls, query.sort)
         .map(x => this.resolveName(x.stack))
         .join(', ');
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const where = query.where as WhereClause<T>;
     return `
 ${this.getSelectSQL(cls, query.select)}
 ${this.getFromSQL(cls)}
@@ -647,14 +635,13 @@ ${this.getLimitSQL(cls, query)}`;
     const parent = stack.length > 1;
     const array = parent && config.array;
 
-    if (config.type && RuntimeIndex.getFunctionMetadata(config.type)?.synthetic) {
+    if (config.type && describeFunction(config.type)?.synthetic) {
       throw new AppError(`Cannot create SQL tables for synthetic types, please convert ${SQLUtil.buildPath(stack)} to a concrete class`);
     }
 
     const fields = SchemaRegistry.has(config.type) ?
       [...SQLUtil.getFieldsByLocation(stack).local] :
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      (array ? [config as FieldConfig] : []);
+      (array ? [castTo<FieldConfig>(config)] : []);
 
     if (!parent) {
       let idField = fields.find(x => x.name === this.idField.name);
@@ -674,7 +661,6 @@ ${this.getLimitSQL(cls, query)}`;
       .filter(x => !!x.trim())
       .join(',\n  ');
 
-    /* eslint-disable @typescript-eslint/indent */
     const out = `
 CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
   ${fieldSql}${fieldSql.length ? ',' : ''}
@@ -734,8 +720,7 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
       if (DataUtil.isPlainObject(val)) {
         throw new Error('Unable to supported nested fields for indices');
       }
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return [key as string, typeof val === 'number' ? val === 1 : (!!val)];
+      return [castTo(key), typeof val === 'number' ? val === 1 : (!!val)];
     });
     const constraint = `idx_${table}_${fields.map(([f]) => f).join('_')}`;
     return `CREATE ${idx.type === 'unique' ? 'UNIQUE ' : ''}INDEX ${constraint} ON ${this.ident(table)} (${fields
@@ -809,8 +794,7 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
       return;
     }
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const matrix = instances.map(inst => columns.map(c => this.resolveValue(c, (inst.value as Record<string, string>)[c.name])));
+    const matrix = instances.map(inst => columns.map(c => this.resolveValue(c, castTo<Record<string, unknown>>(inst.value)[c.name])));
 
     columnNames.push(this.pathField.name);
     if (hasParent) {
@@ -900,13 +884,11 @@ ${orderBy};`;
   /**
    * Get COUNT(1) query
    */
-  getQueryCountSQL<T>(cls: Class<T>, query: Query<T>): string {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const where = query.where as WhereClause<T>;
+  getQueryCountSQL<T>(cls: Class<T>, where?: WhereClause<T>): string {
     return `
 SELECT COUNT(DISTINCT ${this.rootAlias}.id) as total
 ${this.getFromSQL(cls)}
-${this.getWhereSQL(cls, where)}`;
+${this.getWhereSQL(cls, where!)}`;
   }
 
   async fetchDependents<T>(cls: Class<T>, items: T[], select?: SelectClause<T>): Promise<T[]> {
@@ -927,15 +909,12 @@ ${this.getWhereSQL(cls, where)}`;
         const top = stack[stack.length - 1];
         const ids = Object.keys(top);
         const selectTop = selectStack[selectStack.length - 1];
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const fieldKey = config.name as keyof RetainFields<T>;
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const subSelectTop: SelectClause<T> | undefined = selectTop?.[fieldKey] as SelectClause<T> | undefined;
+        const fieldKey = castKey<RetainFields<T>>(config.name);
+        const subSelectTop: SelectClause<T> | undefined = castTo(selectTop?.[fieldKey]);
 
         // See if a selection exists at all
         const sel: FieldConfig[] = subSelectTop ? fields
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          .filter(f => typeof subSelectTop === 'object' && subSelectTop[f.name as typeof fieldKey] === 1)
+          .filter(f => typeof subSelectTop === 'object' && subSelectTop[castTo<typeof fieldKey>(f.name)] === 1)
           : [];
 
         if (sel.length) {
@@ -1018,12 +997,10 @@ ${this.getWhereSQL(cls, where)}`;
 
       await Promise.all([
         ...upserts.filter(x => x.stack.length === 1).map(i =>
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          this.deleteByIds(i.stack, i.records.map(v => (v.value as Record<string, string>)[idx]))
+          this.deleteByIds(i.stack, i.records.map(v => castTo<Record<string, string>>(v.value)[idx]))
         ),
         ...updates.filter(x => x.stack.length === 1).map(i =>
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          this.deleteByIds(i.stack, i.records.map(v => (v.value as Record<string, string>)[idx]))
+          this.deleteByIds(i.stack, i.records.map(v => castTo<Record<string, string>>(v.value)[idx]))
         ),
       ]);
     }

package/src/internal/util.ts

@@ -1,4 +1,4 @@
-import { Class, TypedObject } from '@travetto/base';
+import { castKey, castTo, Class, TypedObject } from '@travetto/runtime';
 import { SelectClause, SortClause } from '@travetto/model-query';
 import { ModelRegistry, ModelType, OptionalId } from '@travetto/model';
 import { SchemaRegistry, ClassConfig, FieldConfig, DataUtil } from '@travetto/schema';
@@ -53,11 +53,9 @@ export class SQLUtil {
           o[k] = this.cleanResults(dct, o[k]);
         }
       }
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return { ...o } as unknown as U[];
+      return castTo({ ...o });
     } else {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return o as unknown as U;
+      return castTo(o);
     }
   }
 
@@ -73,8 +71,7 @@ export class SQLUtil {
     }
 
     if (!cls) { // If a simple type, it is it's own field
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const field = { ...top } as FieldConfig;
+      const field: FieldConfig = castTo({ ...top });
       return {
         local: [field], localMap: { [field.name]: field },
         foreign: [], foreignMap: {}
@@ -184,8 +181,7 @@ export class SQLUtil {
       },
       onSub: (config) => {
         const { config: field } = config;
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const topObj = pathObj[pathObj.length - 1] as Record<string, unknown>;
+        const topObj: Record<string, unknown> = castTo(pathObj[pathObj.length - 1]);
         const top = config.path[config.path.length - 1];
 
         if (field.name in topObj) {
@@ -213,8 +209,7 @@ export class SQLUtil {
       },
       onSimple: (config) => {
         const { config: field } = config;
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const topObj = pathObj[pathObj.length - 1] as Record<string, unknown>;
+        const topObj: Record<string, unknown> = castTo(pathObj[pathObj.length - 1]);
         const value = topObj[field.name];
         return handler.onSimple({ ...config, value });
       }
@@ -234,16 +229,14 @@ export class SQLUtil {
     let toGet = new Set<string>();
 
     for (const [k, v] of TypedObject.entries(select)) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const sk = k as string;
-      if (!DataUtil.isPlainObject(select[k]) && localMap[sk]) {
+      if (typeof k === 'string' && !DataUtil.isPlainObject(select[k]) && localMap[k]) {
         if (!v) {
           if (toGet.size === 0) {
             toGet = new Set(SchemaRegistry.get(cls).views[AllViewⲐ].fields);
           }
-          toGet.delete(sk);
+          toGet.delete(k);
         } else {
-          toGet.add(sk);
+          toGet.add(k);
         }
       }
     }
@@ -268,8 +261,7 @@ export class SQLUtil {
         } else {
           stack.push(field);
           schema = SchemaRegistry.get(field.type);
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          cl = val as Record<string, unknown>;
+          cl = castTo(val);
         }
       }
       return found;
@@ -283,29 +275,24 @@ export class SQLUtil {
     if (field) {
       const isSimple = SchemaRegistry.has(field.type);
       for (const el of v) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const parentKey = el[dct.parentPathField.name as keyof T] as unknown as string;
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const root = (parent as Record<string, Record<string, unknown>>)[parentKey];
+        const parentKey: string = castTo(el[castKey<T>(dct.parentPathField.name)]);
+        const root = castTo<Record<string, Record<string, unknown>>>(parent)[parentKey];
+        const fieldKey = castKey<(typeof root) | T>(field.name);
         if (field.array) {
-          if (!root[field.name]) {
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            root[field.name] = [isSimple ? el : el[field.name as keyof T]];
-          } else {
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            (root[field.name] as unknown[]).push(isSimple ? el : el[field.name as keyof T]);
+          if (!root[fieldKey]) {
+            root[fieldKey] = [isSimple ? el : el[fieldKey]];
+          } else if (Array.isArray(root[fieldKey])) {
+            root[fieldKey].push(isSimple ? el : el[fieldKey]);
           }
         } else {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          root[field.name] = isSimple ? el : el[field.name as keyof T];
+          root[fieldKey] = isSimple ? el : el[fieldKey];
         }
       }
     }
 
     const mapping: Record<string, T> = {};
     for (const el of v) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const key = el[dct.pathField.name as keyof T];
+      const key = el[castKey<T>(dct.pathField.name)];
       if (typeof key === 'string') {
         mapping[key] = el;
       }

package/src/service.ts

@@ -4,13 +4,13 @@ import {
   NotFoundError, ModelRegistry, ExistsError, OptionalId,
   ModelIdSource
 } from '@travetto/model';
-import { Class } from '@travetto/base';
+import { castTo, Class } from '@travetto/runtime';
 import { DataUtil, SchemaChange } from '@travetto/schema';
 import { AsyncContext } from '@travetto/context';
 import { Injectable } from '@travetto/di';
 import {
   ModelQuery, ModelQueryCrudSupport, ModelQueryFacetSupport, ModelQuerySupport,
-  PageableModelQuery, ValidStringFields, WhereClause, WhereClauseRaw,
+  PageableModelQuery, ValidStringFields, WhereClauseRaw, QueryVerifier
 } from '@travetto/model-query';
 
 import { ModelQueryUtil } from '@travetto/model-query/src/internal/service/query';
@@ -95,8 +95,7 @@ export class SQLModelService implements
   }
 
   async #deleteRaw<T extends ModelType>(cls: Class<T>, id: string, where?: WhereClauseRaw<T>, checkExpiry = true): Promise<void> {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    ((where ??= {}) as WhereClauseRaw<ModelType>).id = id;
+    castTo<WhereClauseRaw<ModelType>>(where ??= {}).id = id;
 
     const count = await this.#dialect.deleteAndGetCount<ModelType>(cls, {
       where: ModelQueryUtil.getWhereClause(cls, where, checkExpiry)
@@ -191,8 +190,7 @@ export class SQLModelService implements
 
   @Connected()
   async get<T extends ModelType>(cls: Class<T>, id: string): Promise<T> {
-    const where: WhereClauseRaw<ModelType> = { id };
-    const res = await this.query(cls, { where });
+    const res = await this.query(cls, { where: castTo({ id }) });
     if (res.length === 1) {
       return await ModelCrudUtil.load(cls, res[0]);
     }
@@ -250,7 +248,8 @@ export class SQLModelService implements
 
   @Connected()
   async query<T extends ModelType>(cls: Class<T>, query: PageableModelQuery<T>): Promise<T[]> {
-    const { records: res } = await this.#exec<T>(this.#dialect.getQuerySQL(cls, ModelQueryUtil.getQueryAndVerify(cls, query)));
+    await QueryVerifier.verify(cls, query);
+    const { records: res } = await this.#exec<T>(this.#dialect.getQuerySQL(cls, query, ModelQueryUtil.getWhereClause(cls, query.where)));
     if (ModelRegistry.has(cls)) {
       await this.#dialect.fetchDependents(cls, res, query && query.select);
     }
@@ -267,35 +266,40 @@ export class SQLModelService implements
 
   @Connected()
   async queryCount<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number> {
-    const { records } = await this.#exec<{ total: string | number }>(this.#dialect.getQueryCountSQL(cls, ModelQueryUtil.getQueryAndVerify(cls, query)));
+    await QueryVerifier.verify(cls, query);
+    const { records } = await this.#exec<{ total: string | number }>(this.#dialect.getQueryCountSQL(cls, ModelQueryUtil.getWhereClause(cls, query.where)));
     return +records[0].total;
   }
 
   @Connected()
   @Transactional()
   async updateOneWithQuery<T extends ModelType>(cls: Class<T>, item: T, query: ModelQuery<T>): Promise<T> {
-    query = ModelQueryUtil.getQueryWithId(cls, item, query);
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    await this.#deleteRaw(cls, item.id, query.where as WhereClause<T>, true);
+    await QueryVerifier.verify(cls, query);
+    const where = ModelQueryUtil.getWhereClause(cls, query.where);
+    where.id = item.id;
+    await this.#deleteRaw(cls, item.id, where, true);
     return await this.create(cls, item);
   }
 
   @Connected()
   @Transactional()
   async updateByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>, data: Partial<T>): Promise<number> {
-    const { count } = await this.#exec(this.#dialect.getUpdateSQL(SQLUtil.classToStack(cls), data, ModelQueryUtil.getQueryAndVerify(cls, query).where));
+    await QueryVerifier.verify(cls, query);
+    const { count } = await this.#exec(this.#dialect.getUpdateSQL(SQLUtil.classToStack(cls), data, ModelQueryUtil.getWhereClause(cls, query.where)));
     return count;
   }
 
   @Connected()
   @Transactional()
   async deleteByQuery<T extends ModelType>(cls: Class<T>, query: ModelQuery<T>): Promise<number> {
-    const { count } = await this.#exec(this.#dialect.getDeleteSQL(SQLUtil.classToStack(cls), ModelQueryUtil.getQueryAndVerify(cls, query, false).where));
+    await QueryVerifier.verify(cls, query);
+    const { count } = await this.#exec(this.#dialect.getDeleteSQL(SQLUtil.classToStack(cls), ModelQueryUtil.getWhereClause(cls, query.where, false)));
     return count;
   }
 
   @Connected()
   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, (a, b) => b, query?.limit);
@@ -303,16 +307,17 @@ export class SQLModelService implements
 
   @Connected()
   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(cls, field, prefix, query);
     const results = await this.query(cls, q);
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const modelTypeField = field as ValidStringFields<ModelType>;
+    const modelTypeField: ValidStringFields<ModelType> = castTo(field);
     return ModelQuerySuggestUtil.combineSuggestResults(cls, modelTypeField, prefix, results, x => x, query?.limit);
   }
 
   @Connected()
   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 = this.#dialect.ident(field);
     const ttl = this.#dialect.ident('count');
     const key = this.#dialect.ident('key');
@@ -321,7 +326,7 @@ export class SQLModelService implements
       this.#dialect.getFromSQL(cls),
     ];
     q.push(
-      this.#dialect.getWhereSQL(cls, ModelQueryUtil.getQueryAndVerify(cls, query ?? {}).where)
+      this.#dialect.getWhereSQL(cls, ModelQueryUtil.getWhereClause(cls, query?.where))
     );
     q.push(
       `GROUP BY ${col}`,

package/src/table-manager.ts

@@ -1,6 +1,6 @@
 import { AsyncContext, WithAsyncContext } from '@travetto/context';
 import { ModelRegistry } from '@travetto/model';
-import { Class } from '@travetto/base';
+import { Class } from '@travetto/runtime';
 import { ChangeEvent } from '@travetto/registry';
 import { SchemaChange } from '@travetto/schema';
 

package/support/test/query.ts

@@ -6,6 +6,7 @@ import { BaseModelSuite } from '@travetto/model/support/test/base';
 
 import { VisitStack } from '../../src/internal/util';
 import { SQLModelService } from '../../src/service';
+import { castTo } from '@travetto/runtime';
 
 @Schema()
 class User {
@@ -66,8 +67,8 @@ export abstract class BaseSQLTest extends BaseModelSuite<SQLModelService> {
 
     const dct = await this.dialect;
     dct.resolveName = (stack: VisitStack[]) => {
-      const field = stack[stack.length - 1] as FieldConfig;
-      const parent = stack[stack.length - 2] as FieldConfig;
+      const field: FieldConfig = castTo(stack[stack.length - 1]);
+      const parent: FieldConfig = castTo(stack[stack.length - 2]);
       return `${field.owner ? field.owner.name : parent.name}.${field.name}`;
     };
 
@@ -79,7 +80,7 @@ export abstract class BaseSQLTest extends BaseModelSuite<SQLModelService> {
   async testRegEx() {
     const dct = await this.dialect;
     dct.resolveName = (stack: VisitStack[]) => {
-      const field = stack[stack.length - 1] as FieldConfig;
+      const field: FieldConfig = castTo(stack[stack.length - 1]);
       return `${field.owner?.name}.${field.name}`;
     };