@travetto/model-sql 2.1.4 → 2.2.1

package/README.md

@@ -20,7 +20,7 @@ or
 npm install pg
 ```
 
-This module provides a [SQL](https://en.wikipedia.org/wiki/SQL)-based implementation for the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module.  This source allows the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module to read, write and query against [SQL](https://en.wikipedia.org/wiki/SQL) databases. In development mode, the [SQLModelService](https://github.com/travetto/travetto/tree/main/module/model-sql/src/service.ts#L36) will also modify the database schema in real time to minimize impact to development.
+This module provides a [SQL](https://en.wikipedia.org/wiki/SQL)-based implementation for the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module.  This source allows the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module to read, write and query against [SQL](https://en.wikipedia.org/wiki/SQL) databases. In development mode, the [SQLModelService](https://github.com/travetto/travetto/tree/main/module/model-sql/src/service.ts#L38) will also modify the database schema in real time to minimize impact to development.
 
 The schema generated will not generally map to existing tables as it is attempting to produce a document store like experience on top of
 a [SQL](https://en.wikipedia.org/wiki/SQL) database.  Every table generated will have a `path_id` which determines it's location in the document hierarchy as well as sub tables will have a `parent_path_id` to associate records with the parent values.
@@ -34,7 +34,7 @@ The current SQL client support stands at:
 
 **Note**: Wider client support will roll out as usage increases.
 
-Supported featrues:
+Supported features:
    
    *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/service/crud.ts#L11)
    *  [Bulk](https://github.com/travetto/travetto/tree/main/module/model/src/service/bulk.ts#L23)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/model-sql",
   "displayName": "SQL Model Service",
-  "version": "2.1.4",
+  "version": "2.2.1",
   "description": "SQL backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
     "sql",
@@ -28,13 +28,13 @@
     "directory": "module/model-sql"
   },
   "dependencies": {
-    "@travetto/config": "^2.1.4",
-    "@travetto/context": "^2.1.4",
-    "@travetto/model": "^2.1.4",
-    "@travetto/model-query": "2.1.4"
+    "@travetto/config": "^2.2.1",
+    "@travetto/context": "^2.2.1",
+    "@travetto/model": "^2.2.1",
+    "@travetto/model-query": "2.2.1"
   },
   "devDependencies": {
-    "@travetto/app": "^2.1.4"
+    "@travetto/app": "^2.2.1"
   },
   "optionalPeerDependencies": {
     "@types/mysql": "^2.15.21",

package/src/connection/base.ts

@@ -24,14 +24,14 @@ export abstract class Connection<C = unknown> {
    * Get active connection
    */
   get active(): C {
-    return this.context.get(ContextActiveⲐ) as C;
+    return this.context.get<C>(ContextActiveⲐ);
   }
 
   /**
    * Get active tx state
    */
-  get activeTx() {
-    return !!this.context.get(TxActiveⲐ) as boolean;
+  get activeTx(): boolean {
+    return !!this.context.get<boolean>(TxActiveⲐ);
   }
 
   /**
@@ -85,7 +85,7 @@ export abstract class Connection<C = unknown> {
    * @param op
    * @param args
    */
-  async * iterateWithActive<R>(op: () => AsyncGenerator<R>) {
+  async * iterateWithActive<R>(op: () => AsyncGenerator<R>): AsyncIterable<R> {
     if (this.active) {
       yield* op();
     }
@@ -134,7 +134,7 @@ export abstract class Connection<C = unknown> {
   /**
    * Start a transaction
    */
-  async startTx(conn: C, transactionId?: string) {
+  async startTx(conn: C, transactionId?: string): Promise<void> {
     if (transactionId) {
       if (this.nestedTransactions) {
         await this.execute(conn, `SAVEPOINT ${transactionId};`);
@@ -150,7 +150,7 @@ export abstract class Connection<C = unknown> {
   /**
    * Commit active transaction
    */
-  async commitTx(conn: C, transactionId?: string) {
+  async commitTx(conn: C, transactionId?: string): Promise<void> {
     if (transactionId) {
       if (this.nestedTransactions) {
         await this.execute(conn, `RELEASE SAVEPOINT ${transactionId};`);
@@ -163,7 +163,7 @@ export abstract class Connection<C = unknown> {
   /**
    * Rollback active transaction
    */
-  async rollbackTx(conn: C, transactionId?: string) {
+  async rollbackTx(conn: C, transactionId?: string): Promise<void> {
     if (transactionId) {
       if (this.isolatedTransactions) {
         await this.execute(conn, `ROLLBACK TO ${transactionId};`);

package/src/connection/decorator.ts

@@ -12,12 +12,12 @@ 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: MethodDescriptor) {
+  return function (target: T, prop: string | symbol, desc: MethodDescriptor): void {
     const og = desc.value!;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    desc.value = async function (this: any, ...args: any[]) {
+    // 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;
   };
 }
 
@@ -25,12 +25,12 @@ export function Connected<T extends ConnectionAware>() {
  * Decorator to ensure a method runs with a valid connection
  */
 export function ConnectedIterator<T extends ConnectionAware>() {
-  return function (target: T, prop: string | symbol, desc: MethodDescriptor) {
+  return function (target: T, prop: string | symbol, desc: MethodDescriptor): void {
     const og = desc.value!;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    desc.value = async function* (this: any, ...args: any[]) {
+    // 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;
   };
 }
 
@@ -38,11 +38,11 @@ export function ConnectedIterator<T extends ConnectionAware>() {
  * 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: MethodDescriptor) {
+  return function (target: T, prop: string | symbol, desc: MethodDescriptor): void {
     const og = desc.value!;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    desc.value = function (this: any, ...args: any[]) {
+    // 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;
   };
 }

package/src/dialect/base.ts

@@ -1,6 +1,6 @@
 import { SchemaRegistry, FieldConfig, Schema } from '@travetto/schema';
 import { Class, Util, AppError } from '@travetto/base';
-import { SelectClause, Query, SortClause, WhereClause } from '@travetto/model-query';
+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';
 import { ModelType } from '@travetto/model/src/types/model';
@@ -10,8 +10,11 @@ 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 {
@@ -24,15 +27,14 @@ class Total {
   total: number;
 }
 
-function makeField(name: string, type: Class, required: boolean, extra: Partial<FieldConfig>) {
+function makeField(name: string, type: Class, required: boolean, extra: Partial<FieldConfig>): FieldConfig {
   return {
     name,
-    owner: null,
     type,
     array: false,
     ...(required ? { required: { active: true } } : {}),
     ...extra
-  } as FieldConfig;
+  };
 }
 
 /**
@@ -81,7 +83,7 @@ export abstract class SQLDialect implements DialectState {
     BOOLEAN: 'BOOLEAN',
     TINYINT: 'TINYINT',
     SMALLINT: 'SMALLINT',
-    MEDIUMINIT: 'MEDIUMINT',
+    MEDIUMINT: 'MEDIUMINT',
     INT: 'INT',
     BIGINT: 'BIGINT',
     TIMESTAMP: 'TIMESTAMP',
@@ -91,7 +93,7 @@ export abstract class SQLDialect implements DialectState {
   /**
    * Column types with inputs
    */
-  PARAMETERIZED_COLUMN_TYPES: Record<'VARCHAR' | 'DECIMAL', (...nums: number[]) => string> = {
+  PARAMETERIZED_COLUMN_TYPES: Record<'VARCHAR' | 'DECIMAL', (...values: number[]) => string> = {
     VARCHAR: n => `VARCHAR(${n})`,
     DECIMAL: (d, p) => `DECIMAL(${d},${p})`
   };
@@ -153,7 +155,7 @@ export abstract class SQLDialect implements DialectState {
    */
   abstract hash(inp: string): string;
 
-  executeSQL<T>(sql: string) {
+  executeSQL<T>(sql: string): Promise<{ records: T[], count: number }> {
     return this.conn.execute<T>(this.conn.active, sql);
   }
 
@@ -171,15 +173,15 @@ export abstract class SQLDialect implements DialectState {
    * @param value
    * @returns
    */
-  resolveDateValue(value: Date) {
-    const [day, time] = (value as Date).toISOString().split(/[TZ]/);
+  resolveDateValue(value: Date): string {
+    const [day, time] = value.toISOString().split(/[TZ]/);
     return this.quote(`${day} ${time}`);
   }
 
   /**
    * Convert value to SQL valid representation
    */
-  resolveValue(conf: FieldConfig, value: unknown) {
+  resolveValue(conf: FieldConfig, value: unknown): string {
     if (value === undefined || value === null) {
       return 'NULL';
     } else if (conf.type === String) {
@@ -187,6 +189,7 @@ export abstract class SQLDialect implements DialectState {
         const src = Util.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);
       }
     } else if (conf.type === Boolean) {
@@ -194,6 +197,7 @@ export abstract class SQLDialect implements DialectState {
     } 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);
     } else if (conf.type === PointImpl && Array.isArray(value)) {
       return `point(${value[0]},${value[1]})`;
@@ -206,7 +210,7 @@ export abstract class SQLDialect implements DialectState {
   /**
    * Get column type from field config
    */
-  getColumnType(conf: FieldConfig) {
+  getColumnType(conf: FieldConfig): string {
     let type: string = '';
 
     if (conf.type === Number) {
@@ -221,7 +225,7 @@ export abstract class SQLDialect implements DialectState {
           } else if (digits < 5) {
             type = this.COLUMN_TYPES.SMALLINT;
           } else if (digits < 7) {
-            type = this.COLUMN_TYPES.MEDIUMINIT;
+            type = this.COLUMN_TYPES.MEDIUMINT;
           } else if (digits < 10) {
             type = this.COLUMN_TYPES.INT;
           } else {
@@ -253,7 +257,7 @@ export abstract class SQLDialect implements DialectState {
   /**
    * FieldConfig to Column definition
    */
-  getColumnDefinition(conf: FieldConfig) {
+  getColumnDefinition(conf: FieldConfig): string | undefined {
     const type = this.getColumnType(conf);
     if (!type) {
       return;
@@ -264,7 +268,8 @@ export abstract class SQLDialect implements DialectState {
   /**
    * Delete query and return count removed
    */
-  async deleteAndGetCount<T>(cls: Class<T>, query: Query<T>) {
+  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>));
     return count;
   }
@@ -272,7 +277,7 @@ export abstract class SQLDialect implements DialectState {
   /**
    * Get the count for a given query
    */
-  async getCountForQuery<T>(cls: Class<T>, query: Query<T>) {
+  async getCountForQuery<T>(cls: Class<T>, query: Query<T>): Promise<number> {
     const { records } = await this.executeSQL<{ total: number }>(this.getQueryCountSQL(cls, query));
     const [record] = records;
     return Total.from(record).total;
@@ -281,7 +286,7 @@ export abstract class SQLDialect implements DialectState {
   /**
    * Remove a sql column
    */
-  getDropColumnSQL(stack: VisitStack[]) {
+  getDropColumnSQL(stack: VisitStack[]): string {
     const field = stack[stack.length - 1];
     return `ALTER TABLE ${this.parentTable(stack)} DROP COLUMN ${this.ident(field.name)};`;
   }
@@ -289,8 +294,9 @@ export abstract class SQLDialect implements DialectState {
   /**
    * Add a sql column
    */
-  getAddColumnSQL(stack: VisitStack[]) {
+  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)};`;
   }
 
@@ -309,49 +315,49 @@ export abstract class SQLDialect implements DialectState {
   /**
    * Determine table/field namespace for a given stack location
    */
-  namespace(stack: VisitStack[]) {
+  namespace(stack: VisitStack[]): string {
     return `${this.ns}${SQLUtil.buildTable(stack)}`;
   }
 
   /**
    * Determine  namespace for a given stack location - 1
    */
-  namespaceParent(stack: VisitStack[]) {
+  namespaceParent(stack: VisitStack[]): string {
     return this.namespace(stack.slice(0, stack.length - 1));
   }
 
   /**
    * Determine table name for a given stack location
    */
-  table(stack: VisitStack[]) {
+  table(stack: VisitStack[]): string {
     return this.ident(this.namespace(stack));
   }
 
   /**
    * Determine parent table name for a given stack location
    */
-  parentTable(stack: VisitStack[]) {
+  parentTable(stack: VisitStack[]): string {
     return this.table(stack.slice(0, stack.length - 1));
   }
 
   /**
    * Get lookup key for cls and name
    */
-  getKey(cls: Class, name: string) {
+  getKey(cls: Class, name: string): string {
     return `${cls.name}:${name}`;
   }
 
   /**
    * Alias a field for usage
    */
-  alias(field: string | FieldConfig, alias: string = this.rootAlias) {
+  alias(field: string | FieldConfig, alias: string = this.rootAlias): string {
     return `${alias}.${this.ident(field)}`;
   }
 
   /**
    * Get alias cache for the stack
    */
-  getAliasCache(stack: VisitStack[], resolve: (path: VisitStack[]) => string) {
+  getAliasCache(stack: VisitStack[], resolve: (path: VisitStack[]) => string): Map<string, Alias> {
     const cls = stack[0].type;
 
     if (this.aliasCache.has(cls)) {
@@ -402,7 +408,7 @@ export abstract class SQLDialect implements DialectState {
     const { foreignMap, localMap } = SQLUtil.getFieldsByLocation(stack);
     const SQL_OPS = this.SQL_OPS;
 
-    for (const key of Object.keys(o) as ((keyof (typeof o)))[]) {
+    for (const key of Object.keys(o)) {
       const top = o[key];
       const field = localMap[key] ?? foreignMap[key];
       if (!field) {
@@ -437,18 +443,19 @@ export abstract class SQLDialect implements DialectState {
               const arr = [...new Set(Array.isArray(v) ? v : [v])].map(el => resolve(el));
               const valueTable = this.parentTable(sStack);
               const alias = `_all_${sStack.length}`;
-              const ppath = this.ident(this.parentPathField.name);
-              const rppath = this.resolveName([...sStack, field, this.parentPathField]);
+              const pPath = this.ident(this.parentPathField.name);
+              const rpPath = this.resolveName([...sStack, field, this.parentPathField]);
 
               items.push(`${arr.length} = (
                 SELECT COUNT(DISTINCT ${alias}.${this.ident(field.name)}) 
                 FROM ${valueTable} ${alias} 
-                WHERE ${alias}.${ppath} = ${rppath}
+                WHERE ${alias}.${pPath} = ${rpPath}
                 AND ${alias}.${this.ident(field.name)} IN (${arr.join(',')})
               )`);
               break;
             }
             case '$regex': {
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
               const re = Util.toRegex(v as string);
               const src = re.source;
               const ins = re.flags && re.flags.includes('i');
@@ -482,7 +489,8 @@ export abstract class SQLDialect implements DialectState {
               break;
             }
             case '$lt': case '$gt': case '$gte': case '$lte': {
-              const subItems = (Object.keys(top) as (keyof typeof SQL_OPS)[])
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              const subItems = Object.keys(top as typeof SQL_OPS)
                 .map(ssk => `${sPath} ${SQL_OPS[ssk]} ${resolve(top[ssk])}`);
               items.push(subItems.length > 1 ? `(${subItems.join(` ${SQL_OPS.$and} `)})` : subItems[0]);
               break;
@@ -529,6 +537,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>)}`;
   }
 
@@ -598,16 +607,19 @@ LEFT OUTER JOIN ${from} ON
   /**
    * Generate full query
    */
-  getQuerySQL<T>(cls: Class<T>, query: Query<T>) {
+  getQuerySQL<T>(cls: Class<T>, query: Query<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)}
-${this.getWhereSQL(cls, query.where as WhereClause<T>)}
+${this.getWhereSQL(cls, where)}
 ${this.getGroupBySQL(cls, query)}${sortFields ? `, ${sortFields}` : ''}
 ${this.getOrderBySQL(cls, query.sort)}
 ${this.getLimitSQL(cls, query)}`;
@@ -624,6 +636,7 @@ ${this.getLimitSQL(cls, query)}`;
 
     const fields = SchemaRegistry.has(config.type) ?
       [...SQLUtil.getFieldsByLocation(stack).local] :
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       (array ? [config as FieldConfig] : []);
 
     if (!parent) {
@@ -660,19 +673,19 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
   /**
    * Generate drop SQL
    */
-  getDropTableSQL(stack: VisitStack[]) {
+  getDropTableSQL(stack: VisitStack[]): string {
     return `DROP TABLE IF EXISTS ${this.table(stack)}; `;
   }
 
   /**
    * Generate truncate SQL
    */
-  getTruncateTableSQL(stack: VisitStack[]) {
+  getTruncateTableSQL(stack: VisitStack[]): string {
     return `TRUNCATE ${this.table(stack)}; `;
   }
 
   /**
-   * Get all table creat queries for a class
+   * Get all table create queries for a class
    */
   getCreateAllTablesSQL(cls: Class): string[] {
     const out: string[] = [];
@@ -697,11 +710,12 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
   getCreateIndexSQL<T extends ModelType>(cls: Class<T>, idx: IndexConfig<T>): string {
     const table = this.namespace(SQLUtil.classToStack(cls));
     const fields: [string, boolean][] = idx.fields.map(x => {
-      const key = Object.keys(x)[0] as keyof typeof x;
+      const key = Object.keys(x)[0];
       const val = x[key];
       if (Util.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)];
     });
     const constraint = `idx_${table}_${fields.map(([f]) => f).join('_')}`;
@@ -751,7 +765,7 @@ CREATE TABLE IF NOT EXISTS ${this.table(stack)} (
     const isArray = !!config.array;
 
     if (isArray) {
-      const newInstances = [] as InsertWrapper['records'];
+      const newInstances: typeof instances = [];
       for (const el of instances) {
         if (el.value === null || el.value === undefined) {
           continue;
@@ -776,6 +790,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])));
 
     columnNames.push(this.pathField.name);
@@ -812,7 +827,7 @@ ${matrix.map(row => `(${row.join(', ')})`).join(',\n')};`;
    */
   getAllInsertSQL<T extends ModelType>(cls: Class<T>, instance: T): string[] {
     const out: string[] = [];
-    const add = (text?: string) => text && out.push(text);
+    const add = (text?: string): void => { text && out.push(text); };
     SQLUtil.visitSchemaInstance(cls, instance, {
       onRoot: ({ value, path }) => add(this.getInsertSQL(path, [{ stack: path, value }])),
       onSub: ({ value, path }) => add(this.getInsertSQL(path, [{ stack: path, value }])),
@@ -824,7 +839,7 @@ ${matrix.map(row => `(${row.join(', ')})`).join(',\n')};`;
   /**
    * Simple data base updates
    */
-  getUpdateSQL(stack: VisitStack[], data: Record<string, unknown>, where?: WhereClause<unknown>) {
+  getUpdateSQL(stack: VisitStack[], data: Record<string, unknown>, where?: WhereClause<unknown>): string {
     const { type } = stack[stack.length - 1];
     const { localMap } = SQLUtil.getFieldsByLocation(stack);
     return `
@@ -866,18 +881,21 @@ ${orderBy};`;
   /**
    * Get COUNT(1) query
    */
-  getQueryCountSQL<T>(cls: Class<T>, query: Query<T>) {
+  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>;
     return `
 SELECT COUNT(DISTINCT ${this.rootAlias}.id) as total
 ${this.getFromSQL(cls)}
-${this.getWhereSQL(cls, query.where as WhereClause<T>)}`;
+${this.getWhereSQL(cls, where)}`;
   }
 
   async fetchDependents<T>(cls: Class<T>, items: T[], select?: SelectClause<T>): Promise<T[]> {
     const stack: Record<string, unknown>[] = [];
     const selectStack: (SelectClause<T> | undefined)[] = [];
 
-    const buildSet = (children: unknown[], field?: FieldConfig) => SQLUtil.collectDependents(this, stack[stack.length - 1], children, field);
+    const buildSet = (children: unknown[], field?: FieldConfig): Record<string, unknown> =>
+      SQLUtil.collectDependents(this, stack[stack.length - 1], children, field);
 
     await SQLUtil.visitSchema(SchemaRegistry.get(cls), {
       onRoot: async (config) => {
@@ -890,12 +908,15 @@ ${this.getWhereSQL(cls, query.where as WhereClause<T>)}`;
         const top = stack[stack.length - 1];
         const ids = Object.keys(top);
         const selectTop = selectStack[selectStack.length - 1];
-        // @ts-ignore
-        const subSelectTop: SelectClause<T> | undefined = selectTop?.[config.name];
+        // 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;
 
         // See if a selection exists at all
         const sel: FieldConfig[] = subSelectTop ? fields
-          .filter(f => subSelectTop[f.name as keyof SelectClause<T>] === 1)
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          .filter(f => typeof subSelectTop === 'object' && subSelectTop[f.name as typeof fieldKey] === 1)
           : [];
 
         if (sel.length) {
@@ -924,7 +945,7 @@ ${this.getWhereSQL(cls, query.where as WhereClause<T>)}`;
           }
         }
       },
-      onSimple: async ({ config, path }) => {
+      onSimple: async ({ config, path }): Promise<void> => {
         const top = stack[stack.length - 1];
         const ids = Object.keys(top);
         if (ids.length) {
@@ -943,7 +964,7 @@ ${this.getWhereSQL(cls, query.where as WhereClause<T>)}`;
   /**
    * Delete all ids
    */
-  async deleteByIds(stack: VisitStack[], ids: string[]) {
+  async deleteByIds(stack: VisitStack[], ids: string[]): Promise<number> {
     return this.deleteAndGetCount<ModelType>(stack[stack.length - 1].type, {
       where: {
         [stack.length === 1 ? this.idField.name : this.pathField.name]: {
@@ -956,10 +977,10 @@ ${this.getWhereSQL(cls, query.where as WhereClause<T>)}`;
   /**
    * Do bulk process
    */
-  async bulkProcess(dels: DeleteWrapper[], inserts: InsertWrapper[], upserts: InsertWrapper[], updates: InsertWrapper[]): Promise<BulkResponse> {
+  async bulkProcess(deletes: DeleteWrapper[], inserts: InsertWrapper[], upserts: InsertWrapper[], updates: InsertWrapper[]): Promise<BulkResponse> {
     const out = {
       counts: {
-        delete: dels.reduce((acc, el) => acc + el.ids.length, 0),
+        delete: deletes.reduce((acc, el) => acc + el.ids.length, 0),
         error: 0,
         insert: inserts.filter(x => x.stack.length === 1).reduce((acc, el) => acc + el.records.length, 0),
         update: updates.filter(x => x.stack.length === 1).reduce((acc, el) => acc + el.records.length, 0),
@@ -970,7 +991,7 @@ ${this.getWhereSQL(cls, query.where as WhereClause<T>)}`;
     };
 
     // Full removals
-    await Promise.all(dels.map(el => this.deleteByIds(el.stack, el.ids)));
+    await Promise.all(deletes.map(el => this.deleteByIds(el.stack, el.ids)));
 
     // Adding deletes
     if (upserts.length || updates.length) {
@@ -978,9 +999,11 @@ ${this.getWhereSQL(cls, query.where as WhereClause<T>)}`;
 
       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]))
         ),
         ...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]))
         ),
       ]);

package/src/dialect/mysql/connection.ts

@@ -24,7 +24,7 @@ export class MySQLConnection extends Connection<mysql.PoolConnection> {
     this.#config = config;
   }
 
-  async init() {
+  async init(): Promise<void> {
     this.#pool = mysql.createPool({
       user: this.#config.user,
       password: this.#config.password,
@@ -43,7 +43,7 @@ export class MySQLConnection extends Connection<mysql.PoolConnection> {
   /**
    * Support some basic type support for JSON data
    */
-  typeCast(field: Parameters<Exclude<mysql.TypeCast, boolean>>[0], next: () => unknown) {
+  typeCast(field: Parameters<Exclude<mysql.TypeCast, boolean>>[0], next: () => unknown): unknown {
     const res = next();
     if (typeof res === 'string' && (field.type === 'JSON' || field.type === 'BLOB')) {
       if (res.charAt(0) === '{' && res.charAt(res.length - 1) === '}') {
@@ -67,19 +67,19 @@ export class MySQLConnection extends Connection<mysql.PoolConnection> {
             rej(err);
           }
         } else {
-          const records = Array.isArray(results) ? [...results].map(v => ({ ...v })) : [{ ...results }] as T[];
+          const records: T[] = Array.isArray(results) ? [...results].map(v => ({ ...v })) : [{ ...results }];
           res({ records, count: results.affectedRows });
         }
       });
     });
   }
 
-  acquire() {
+  acquire(): Promise<mysql.PoolConnection> {
     return new Promise<mysql.PoolConnection>((res, rej) =>
       this.#pool.getConnection((err, conn) => err ? rej(err) : res(conn)));
   }
 
-  release(conn: mysql.PoolConnection) {
+  release(conn: mysql.PoolConnection): void {
     conn.release();
   }
 }