@travetto/model-sql 2.1.3 → 2.2.0

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.3",
+  "version": "2.2.0",
   "description": "SQL backing for the travetto model module, with real-time modeling support for SQL schemas.",
   "keywords": [
     "sql",
@@ -28,20 +28,20 @@
     "directory": "module/model-sql"
   },
   "dependencies": {
-    "@travetto/config": "^2.1.3",
-    "@travetto/context": "^2.1.3",
-    "@travetto/model": "^2.1.3",
-    "@travetto/model-query": "2.1.3"
+    "@travetto/config": "^2.2.0",
+    "@travetto/context": "^2.2.0",
+    "@travetto/model": "^2.2.0",
+    "@travetto/model-query": "2.2.0"
   },
   "devDependencies": {
-    "@travetto/app": "^2.1.3"
+    "@travetto/app": "^2.2.0"
   },
   "optionalPeerDependencies": {
     "@types/mysql": "^2.15.21",
     "@types/pg": "^8.6.5",
     "mysql": "^2.18.1",
     "pg": "^8.7.3",
-    "better-sqlite3": "^7.5.3",
+    "better-sqlite3": "^7.6.2",
     "@types/better-sqlite3": "^7.5.0"
   },
   "publishConfig": {

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

@@ -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,16 @@ 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,
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    owner: null as unknown as Class,
     type,
     array: false,
     ...(required ? { required: { active: true } } : {}),
     ...extra
-  } as FieldConfig;
+  };
 }
 
 /**
@@ -81,7 +85,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 +95,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 +157,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 +175,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 +191,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 +199,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 +212,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 +227,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 +259,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 +270,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 +279,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 +288,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 +296,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 +317,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,6 +410,7 @@ export abstract class SQLDialect implements DialectState {
     const { foreignMap, localMap } = SQLUtil.getFieldsByLocation(stack);
     const SQL_OPS = this.SQL_OPS;
 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     for (const key of Object.keys(o) as ((keyof (typeof o)))[]) {
       const top = o[key];
       const field = localMap[key] ?? foreignMap[key];
@@ -437,18 +446,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,6 +492,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 = (Object.keys(top) as (keyof typeof SQL_OPS)[])
                 .map(ssk => `${sPath} ${SQL_OPS[ssk]} ${resolve(top[ssk])}`);
               items.push(subItems.length > 1 ? `(${subItems.join(` ${SQL_OPS.$and} `)})` : subItems[0]);
@@ -529,6 +540,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 +610,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 +639,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 +676,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 +713,13 @@ 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 => {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const key = Object.keys(x)[0] as keyof typeof x;
       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 +769,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 +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])));
 
     columnNames.push(this.pathField.name);
@@ -812,7 +831,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 +843,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 +885,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) => {
@@ -895,6 +917,7 @@ ${this.getWhereSQL(cls, query.where as WhereClause<T>)}`;
 
         // See if a selection exists at all
         const sel: FieldConfig[] = subSelectTop ? fields
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           .filter(f => subSelectTop[f.name as keyof SelectClause<T>] === 1)
           : [];
 
@@ -924,7 +947,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 +966,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 +979,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 +993,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 +1001,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();
   }
 }

package/src/dialect/mysql/dialect.ts

@@ -52,36 +52,37 @@ export class MySQLDialect extends SQLDialect {
   /**
    * Compute hash
    */
-  hash(value: string) {
+  hash(value: string): string {
     return `SHA2('${value}', ${this.KEY_LEN * 4})`;
   }
 
   /**
    * Build identifier
    */
-  ident(field: FieldConfig | string) {
+  ident(field: FieldConfig | string): string {
     return `\`${typeof field === 'string' ? field : field.name}\``;
   }
 
   /**
    * Create table, adding in specific engine options
    */
-  override getCreateTableSQL(stack: VisitStack[]) {
+  override getCreateTableSQL(stack: VisitStack[]): string {
     return super.getCreateTableSQL(stack).replace(/;$/, ` ${this.tablePostfix};`);
   }
 
   /**
    * Define column modification
    */
-  getModifyColumnSQL(stack: VisitStack[]) {
-    const field = stack[stack.length - 1];
-    return `ALTER TABLE ${this.parentTable(stack)} MODIFY COLUMN ${this.getColumnDefinition(field as FieldConfig)};`;
+  getModifyColumnSQL(stack: VisitStack[]): string {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const field = stack[stack.length - 1] as FieldConfig;
+    return `ALTER TABLE ${this.parentTable(stack)} MODIFY COLUMN ${this.getColumnDefinition(field)};`;
   }
 
   /**
    * Add root alias to delete clause
    */
-  override getDeleteSQL(stack: VisitStack[], where?: WhereClause<unknown>) {
+  override getDeleteSQL(stack: VisitStack[], where?: WhereClause<unknown>): string {
     const sql = super.getDeleteSQL(stack, where);
     return sql.replace(/\bDELETE\b/g, `DELETE ${this.rootAlias}`);
   }

package/src/dialect/postgresql/connection.ts

@@ -28,7 +28,7 @@ export class PostgreSQLConnection extends Connection<pg.PoolClient> {
    * Initializes connection and establishes crypto extension for use with hashing
    */
   @WithAsyncContext()
-  async init() {
+  async init(): Promise<void> {
     this.#pool = new pg.Pool({
       user: this.#config.user,
       password: this.#config.password,
@@ -53,9 +53,10 @@ export class PostgreSQLConnection extends Connection<pg.PoolClient> {
     console.debug('Executing query', { query });
     try {
       const out = await conn.query(query);
-      return { count: out.rowCount, records: [...out.rows].map(v => ({ ...v })) as T[] };
+      const records: T[] = [...out.rows].map(v => ({ ...v }));
+      return { count: out.rowCount, records };
     } catch (err) {
-      if (err.message.includes('duplicate key value')) {
+      if (err instanceof Error && err.message.includes('duplicate key value')) {
         throw new ExistsError('query', query);
       } else {
         throw err;
@@ -63,11 +64,11 @@ export class PostgreSQLConnection extends Connection<pg.PoolClient> {
     }
   }
 
-  acquire() {
+  acquire(): Promise<pg.PoolClient> {
     return this.#pool.connect();
   }
 
-  release(conn: pg.PoolClient) {
+  release(conn: pg.PoolClient): void {
     conn.release();
   }
 }

package/src/dialect/postgresql/dialect.ts

@@ -41,20 +41,21 @@ export class PostgreSQLDialect extends SQLDialect {
   /**
    * How to hash
    */
-  hash(value: string) {
+  hash(value: string): string {
     return `encode(digest('${value}', 'sha1'), 'hex')`;
   }
 
-  ident(field: FieldConfig | string) {
+  ident(field: FieldConfig | string): string {
     return `"${typeof field === 'string' ? field : field.name}"`;
   }
 
   /**
    * Define column modification
    */
-  getModifyColumnSQL(stack: VisitStack[]) {
-    const field = stack[stack.length - 1];
-    const type = this.getColumnType(field as FieldConfig);
+  getModifyColumnSQL(stack: VisitStack[]): string {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const field = stack[stack.length - 1] as FieldConfig;
+    const type = this.getColumnType(field);
     const ident = this.ident(field.name);
     return `ALTER TABLE ${this.parentTable(stack)} ALTER COLUMN ${ident}  TYPE ${type} USING (${ident}::${type});`;
   }

package/src/dialect/sqlite/connection.ts

@@ -29,12 +29,12 @@ export class SqliteConnection extends Connection<sqlite3.Database> {
     this.#config = config;
   }
 
-  async #withRetries<T>(op: () => Promise<T>, retries = 10, delay = 250) {
+  async #withRetries<T>(op: () => Promise<T>, retries = 10, delay = 250): Promise<T> {
     for (; ;) {
       try {
         return await op();
       } catch (err) {
-        if (retries > 1 && err.message.includes('database is locked')) {
+        if (err instanceof Error && retries > 1 && err.message.includes('database is locked')) {
           console.error('Failed, and waiting', retries);
           await Util.wait(delay);
           retries -= 1;
@@ -49,11 +49,11 @@ export class SqliteConnection extends Connection<sqlite3.Database> {
    * Initializes connection and establishes crypto extension for use with hashing
    */
   @WithAsyncContext()
-  override async init() {
+  override async init(): Promise<void> {
     this.#pool = pool.createPool({
       create: () => this.#withRetries(async () => {
         const db = Db(AppCache.toEntryName('sqlite_db'),
-          this.#config.options as sqlite3.Options
+          this.#config.options
         );
         await db.pragma('foreign_keys = ON');
         await db.pragma('journal_mode = WAL');
@@ -73,21 +73,26 @@ export class SqliteConnection extends Connection<sqlite3.Database> {
       try {
         const out = await conn.prepare(query)[query.trim().startsWith('SELECT') ? 'all' : 'run']();
         if (Array.isArray(out)) {
-          return { count: out.length, records: [...out].map(v => ({ ...v })) as T[] };
+          const records: T[] = [...out].map(v => ({ ...v }));
+          return { count: out.length, records };
         } else {
           return { count: out.changes, records: [] };
         }
       } catch (err) {
-        throw err.message.includes('UNIQUE constraint failed') ? new ExistsError('query', query) : err;
+        if (err instanceof Error && err.message.includes('UNIQUE constraint failed')) {
+          throw new ExistsError('query', query);
+        } else {
+          throw err;
+        }
       }
     });
   }
 
-  async acquire() {
+  async acquire(): Promise<Db.Database> {
     return this.#pool.acquire();
   }
 
-  async release(db: sqlite3.Database) {
+  async release(db: sqlite3.Database): Promise<void> {
     return this.#pool.release(db);
   }
 }

package/src/dialect/sqlite/dialect.ts

@@ -34,30 +34,31 @@ export class SqliteDialect extends SQLDialect {
     });
   }
 
-  override resolveDateValue(value: Date) {
+  override resolveDateValue(value: Date): string {
     return `${value.getTime()}`;
   }
 
   /**
    * How to hash
    */
-  hash(value: string) {
+  hash(value: string): string {
     return `hex('${value}')`;
   }
 
   /**
    * Build identifier
    */
-  ident(field: FieldConfig | string) {
+  ident(field: FieldConfig | string): string {
     return `\`${typeof field === 'string' ? field : field.name}\``;
   }
 
   /**
    * Define column modification
    */
-  getModifyColumnSQL(stack: VisitStack[]) {
-    const field = stack[stack.length - 1];
-    const type = this.getColumnType(field as FieldConfig);
+  getModifyColumnSQL(stack: VisitStack[]): string {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const field = stack[stack.length - 1] as FieldConfig;
+    const type = this.getColumnType(field);
     const ident = this.ident(field.name);
     return `ALTER TABLE ${this.parentTable(stack)} ALTER COLUMN ${ident} TYPE ${type} USING (${ident}::${type});`;
   }
@@ -65,7 +66,7 @@ export class SqliteDialect extends SQLDialect {
   /**
    * Generate truncate SQL
    */
-  override getTruncateTableSQL(stack: VisitStack[]) {
+  override getTruncateTableSQL(stack: VisitStack[]): string {
     return `DELETE FROM ${this.table(stack)};`;
   }
 

package/src/internal/util.ts

@@ -16,17 +16,19 @@ export type VisitStack = {
   index?: number;
 };
 
+type FieldCacheEntry = {
+  local: FieldConfig[];
+  localMap: Record<string, FieldConfig>;
+  foreign: FieldConfig[];
+  foreignMap: Record<string, FieldConfig>;
+};
+
 /**
  * Utilities for dealing with SQL operations
  */
 export class SQLUtil {
 
-  static SCHEMA_FIELDS_CACHE = new Map<Class, {
-    local: FieldConfig[];
-    localMap: Record<string, FieldConfig>;
-    foreign: FieldConfig[];
-    foreignMap: Record<string, FieldConfig>;
-  }>();
+  static SCHEMA_FIELDS_CACHE = new Map<Class, FieldCacheEntry>();
 
   /**
    * Creates a new visitation stack with the class as the root
@@ -44,6 +46,7 @@ export class SQLUtil {
     if (Array.isArray(o)) {
       return o.filter(x => x !== null && x !== undefined).map(x => this.cleanResults(dct, x));
     } else if (!Util.isSimple(o)) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       for (const k of Object.keys(o) as (keyof T)[]) {
         if (o[k] === null || o[k] === undefined || k === dct.parentPathField.name || k === dct.pathField.name || k === dct.idxField.name) {
           delete o[k];
@@ -51,8 +54,10 @@ 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[];
     } else {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return o as unknown as U;
     }
   }
@@ -60,7 +65,7 @@ export class SQLUtil {
   /**
    * Get all available fields at current stack path
    */
-  static getFieldsByLocation(stack: VisitStack[]) {
+  static getFieldsByLocation(stack: VisitStack[]): FieldCacheEntry {
     const top = stack[stack.length - 1];
     const cls = SchemaRegistry.get(top.type);
 
@@ -69,6 +74,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;
       return {
         local: [field], localMap: { [field.name]: field },
@@ -94,9 +100,9 @@ export class SQLUtil {
       }
     }
 
-    const ret = {
-      localMap: {} as Record<string, FieldConfig>,
-      foreignMap: {} as Record<string, FieldConfig>,
+    const ret: FieldCacheEntry = {
+      localMap: {},
+      foreignMap: {},
       local: fields.filter(x => !SchemaRegistry.has(x.type) && !x.array),
       foreign: fields.filter(x => SchemaRegistry.has(x.type) || x.array)
     };
@@ -112,11 +118,11 @@ export class SQLUtil {
   /**
    * Process a schema structure, synchronously
    */
-  static visitSchemaSync(config: ClassConfig | FieldConfig, handler: VisitHandler<void>, state: VisitState = { path: [] }) {
+  static visitSchemaSync(config: ClassConfig | FieldConfig, handler: VisitHandler<void>, state: VisitState = { path: [] }): void {
     const path = 'class' in config ? this.classToStack(config.class) : [...state.path, config];
     const { local: fields, foreign } = this.getFieldsByLocation(path);
 
-    const descend = () => {
+    const descend = (): void => {
       for (const field of foreign) {
         if (SchemaRegistry.has(field.type)) {
           this.visitSchemaSync(field, handler, { path });
@@ -140,11 +146,11 @@ export class SQLUtil {
   /**
    * Visit a Schema structure
    */
-  static async visitSchema(config: ClassConfig | FieldConfig, handler: VisitHandler<Promise<void>>, state: VisitState = { path: [] }) {
+  static async visitSchema(config: ClassConfig | FieldConfig, handler: VisitHandler<Promise<void>>, state: VisitState = { path: [] }): Promise<void> {
     const path = 'class' in config ? this.classToStack(config.class) : [...state.path, config];
     const { local: fields, foreign } = this.getFieldsByLocation(path);
 
-    const descend = async () => {
+    const descend = async (): Promise<void> => {
       for (const field of foreign) {
         if (SchemaRegistry.has(field.type)) {
           await this.visitSchema(field, handler, { path });
@@ -168,7 +174,7 @@ export class SQLUtil {
   /**
    * Process a schema instance by visiting it synchronously.  This is synchronous to prevent concurrent calls from breaking
    */
-  static visitSchemaInstance<T extends ModelType>(cls: Class<T>, instance: T, handler: VisitHandler<unknown, VisitInstanceNode<unknown>>) {
+  static visitSchemaInstance<T extends ModelType>(cls: Class<T>, instance: T, handler: VisitHandler<unknown, VisitInstanceNode<unknown>>): void {
     const pathObj: unknown[] = [instance];
     this.visitSchemaSync(SchemaRegistry.get(cls), {
       onRoot: (config) => {
@@ -179,15 +185,16 @@ 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 top = config.path[config.path.length - 1];
 
         if (field.name in topObj) {
           const value = topObj[field.name];
-          const vals = Array.isArray(value) ? value : [value];
+          const values = Array.isArray(value) ? value : [value];
 
           let i = 0;
-          for (const val of vals) {
+          for (const val of values) {
             try {
               pathObj.push(val);
               config.path[config.path.length - 1] = { ...top, index: i++ };
@@ -202,6 +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 value = topObj[field.name];
         return handler.onSimple({ ...config, value });
@@ -214,7 +222,7 @@ export class SQLUtil {
    */
   static select<T>(cls: Class<T>, select?: SelectClause<T>): FieldConfig[] {
     if (!select || Object.keys(select).length === 0) {
-      return [{ type: cls, name: '*' } as FieldConfig];
+      return [{ type: cls, name: '*', owner: cls, array: false }];
     }
 
     const { localMap } = this.getFieldsByLocation(this.classToStack(cls));
@@ -222,7 +230,9 @@ export class SQLUtil {
     let toGet = new Set<string>();
 
     for (const [k, v] of Object.entries(select)) {
-      if (!Util.isPlainObject(select[k as keyof typeof select]) && localMap[k]) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const typedKey = k as keyof typeof select;
+      if (!Util.isPlainObject(select[typedKey]) && localMap[k]) {
         if (!v) {
           if (toGet.size === 0) {
             toGet = new Set(SchemaRegistry.get(cls).views[AllViewⲐ].fields);
@@ -254,6 +264,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>;
         }
       }
@@ -264,18 +275,24 @@ export class SQLUtil {
   /**
    * Find all dependent fields via child tables
    */
-  static collectDependents<T>(dct: DialectState, parent: unknown, v: T[], field?: FieldConfig) {
+  static collectDependents<T>(dct: DialectState, parent: unknown, v: T[], field?: FieldConfig): Record<string, T> {
     if (field) {
       const isSimple = SchemaRegistry.has(field.type);
       for (const el of v) {
-        const root = (parent as { [k: string]: unknown })[el[dct.parentPathField.name as keyof T] as unknown as string] as unknown as Record<string, unknown>;
+        // 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];
         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]);
           }
         } else {
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           root[field.name] = isSimple ? el : el[field.name as keyof T];
         }
       }
@@ -283,6 +300,7 @@ export class SQLUtil {
 
     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];
       if (typeof key === 'string') {
         mapping[key] = el;
@@ -294,7 +312,7 @@ export class SQLUtil {
   /**
    * Build table name via stack path
    */
-  static buildTable(list: VisitStack[]) {
+  static buildTable(list: VisitStack[]): string {
     const top = list[list.length - 1];
     if (!top[TableⲐ]) {
       top[TableⲐ] = list.map((el, i) => i === 0 ? ModelRegistry.getStore(el.type) : el.name).join('_');
@@ -305,7 +323,7 @@ export class SQLUtil {
   /**
    * Build property path for a table/field given the current stack
    */
-  static buildPath(list: VisitStack[]) {
+  static buildPath(list: VisitStack[]): string {
     return list.map((el, i) => `${el.name}${el.index ? `[${el.index}]` : ''}`).join('.');
   }
 
@@ -313,9 +331,9 @@ export class SQLUtil {
    * Get insert statements for a given class, and its child tables
    */
   static async getInserts<T extends ModelType>(cls: Class<T>, els: T[]): Promise<InsertWrapper[]> {
-    const ins = {} as Record<string, InsertWrapper>;
+    const ins: Record<string, InsertWrapper> = {};
 
-    const track = (stack: VisitStack[], value: unknown) => {
+    const track = (stack: VisitStack[], value: unknown): void => {
       const key = this.buildTable(stack);
       (ins[key] = ins[key] ?? { stack, records: [] }).records.push({ stack, value });
     };

package/src/service.ts

@@ -26,6 +26,8 @@ import { Connected, ConnectedIterator, Transactional } from './connection/decora
 import { SQLUtil } from './internal/util';
 import { SQLDialect } from './dialect/base';
 import { TableManager } from './table-manager';
+import { Connection } from './connection/base';
+import { InsertWrapper } from './internal/types';
 
 /**
  * Core for SQL Model Source.  Should not have any direct queries,
@@ -45,7 +47,7 @@ export class SQLModelService implements
 
   readonly config: SQLModelConfig;
 
-  get client() {
+  get client(): SQLDialect {
     return this.#dialect;
   }
 
@@ -66,7 +68,7 @@ export class SQLModelService implements
     cls: Class<T>,
     addedIds: Map<number, string>,
     toCheck: Map<string, number>
-  ) {
+  ): Promise<Map<number, string>> {
     // Get all upsert ids
     const all = toCheck.size ?
       (await this.#exec<ModelType>(
@@ -86,20 +88,21 @@ export class SQLModelService implements
     return addedIds;
   }
 
-  #exec<T = unknown>(sql: string) {
+  #exec<T = unknown>(sql: string): Promise<{ records: T[], count: number }> {
     return this.#dialect.executeSQL<T>(sql);
   }
 
-  async #deleteRaw<T extends ModelType>(cls: Class<T>, id: string, checkExpiry = true) {
+  async #deleteRaw<T extends ModelType>(cls: Class<T>, id: string, checkExpiry = true): Promise<void> {
+    const where: WhereClauseRaw<ModelType> = { id };
     const count = await this.#dialect.deleteAndGetCount<ModelType>(cls, {
-      where: ModelQueryUtil.getWhereClause(cls, { id } as WhereClauseRaw<T>, checkExpiry)
+      where: ModelQueryUtil.getWhereClause(cls, where, checkExpiry)
     });
     if (count === 0) {
       throw new NotFoundError(cls, id);
     }
   }
 
-  async postConstruct() {
+  async postConstruct(): Promise<void> {
     if (this.#dialect) {
       if (this.#dialect.conn.init) {
         await this.#dialect.conn.init();
@@ -110,32 +113,32 @@ export class SQLModelService implements
     }
   }
 
-  get conn() {
+  get conn(): Connection {
     return this.#dialect.conn;
   }
 
-  uuid() {
+  uuid(): string {
     return this.#dialect.generateId();
   }
 
-  async changeSchema(cls: Class, change: SchemaChange) {
+  async changeSchema(cls: Class, change: SchemaChange): Promise<void> {
     await this.#manager.changeSchema(cls, change);
   }
 
-  async createModel(cls: Class) {
+  async createModel(cls: Class): Promise<void> {
     await this.#manager.createTables(cls);
   }
 
-  async deleteModel(cls: Class) {
+  async deleteModel(cls: Class): Promise<void> {
     await this.#manager.dropTables(cls);
   }
 
-  async truncateModel(cls: Class) {
+  async truncateModel(cls: Class): Promise<void> {
     await this.#manager.truncateTables(cls);
   }
 
-  async createStorage() { }
-  async deleteStorage() { }
+  async createStorage(): Promise<void> { }
+  async deleteStorage(): Promise<void> { }
 
   @Transactional()
   async create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T> {
@@ -183,7 +186,8 @@ export class SQLModelService implements
 
   @Connected()
   async get<T extends ModelType>(cls: Class<T>, id: string): Promise<T> {
-    const res = await this.query(cls, { where: { id } as WhereClauseRaw<T> });
+    const where: WhereClauseRaw<ModelType> = { id };
+    const res = await this.query(cls, { where });
     if (res.length === 1) {
       return await ModelCrudUtil.load(cls, res[0]);
     }
@@ -191,14 +195,14 @@ export class SQLModelService implements
   }
 
   @ConnectedIterator()
-  async * list<T extends ModelType>(cls: Class<T>) {
+  async * list<T extends ModelType>(cls: Class<T>): AsyncIterable<T> {
     for (const item of await this.query(cls, {})) {
       yield await ModelCrudUtil.load(cls, item);
     }
   }
 
   @Transactional()
-  async delete<T extends ModelType>(cls: Class<T>, id: string) {
+  async delete<T extends ModelType>(cls: Class<T>, id: string): Promise<void> {
     await this.#deleteRaw(cls, id, false);
   }
 
@@ -214,8 +218,10 @@ export class SQLModelService implements
       new Map([...existingUpsertedIds.entries()].map(([k, v]) => [v, k]))
     );
 
-    const get = (k: keyof BulkOp<T>) => operations.map(x => x[k]).filter(x => !!x) as T[];
-    const getStatements = async (k: keyof BulkOp<T>) => (await SQLUtil.getInserts(cls, get(k))).filter(x => !!x.records.length);
+    const get = (k: keyof BulkOp<T>): T[] =>
+      operations.map(x => x[k]).filter((x): x is T => !!x);
+    const getStatements = async (k: keyof BulkOp<T>): Promise<InsertWrapper[]> =>
+      (await SQLUtil.getInserts(cls, get(k))).filter(x => !!x.records.length);
 
     const deletes = [{ stack: SQLUtil.classToStack(cls), ids: get('delete').map(x => x.id) }].filter(x => !!x.ids.length);
 
@@ -232,7 +238,7 @@ export class SQLModelService implements
 
   // Expiry
   @Transactional()
-  async deleteExpired<T extends ModelType>(cls: Class<T>) {
+  async deleteExpired<T extends ModelType>(cls: Class<T>): Promise<number> {
     return ModelQueryExpiryUtil.deleteExpired(this, cls);
   }
 
@@ -284,12 +290,15 @@ export class SQLModelService implements
   async suggestValues<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>): Promise<string[]> {
     const q = ModelQuerySuggestUtil.getSuggestFieldQuery(cls, field, prefix, query);
     const results = await this.query(cls, q);
-    return ModelQuerySuggestUtil.combineSuggestResults(cls, field as 'type', prefix, results, x => x, query?.limit);
+
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const modelTypeField = field as ValidStringFields<ModelType>;
+    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 }[]> {
-    const col = this.#dialect.ident(field as string);
+    const col = this.#dialect.ident(field);
     const ttl = this.#dialect.ident('count');
     const key = this.#dialect.ident('key');
     const q = [

package/src/table-manager.ts

@@ -7,6 +7,7 @@ import { SchemaChange } from '@travetto/schema';
 import { Connected, Transactional } from './connection/decorator';
 import { SQLDialect } from './dialect/base';
 import { SQLUtil, VisitStack } from './internal/util';
+import { Connection } from './connection/base';
 
 /**
  * Manage creation/updating of all tables
@@ -22,7 +23,7 @@ export class TableManager {
     this.#dialect = dialect;
   }
 
-  #exec<T = unknown>(sql: string) {
+  #exec<T = unknown>(sql: string): Promise<{ records: T[], count: number }> {
     return this.#dialect.executeSQL<T>(sql);
   }
 
@@ -41,9 +42,12 @@ export class TableManager {
       for (const op of this.#dialect.getCreateAllIndicesSQL(cls, indices)) {
         try {
           await this.#exec(op);
-        } catch (e) {
-          if (!/\bexists|duplicate\b/i.test(e.message)) {
-            throw e;
+        } catch (err) {
+          if (!(err instanceof Error)) {
+            throw err;
+          }
+          if (!/\bexists|duplicate\b/i.test(err.message)) {
+            throw err;
           }
         }
       }
@@ -78,7 +82,7 @@ export class TableManager {
   /**
    * Get a valid connection
    */
-  get conn() {
+  get conn(): Connection {
     return this.#dialect.conn;
   }
 
@@ -88,24 +92,24 @@ export class TableManager {
   @WithAsyncContext({})
   @Transactional()
   @Connected()
-  async changeSchema(cls: Class, change: SchemaChange) {
+  async changeSchema(cls: Class, change: SchemaChange): Promise<void> {
     try {
       const rootStack = SQLUtil.classToStack(cls);
 
-      const changes = change.subs.reduce((acc, v) => {
+      const changes = change.subs.reduce<Record<ChangeEvent<unknown>['type'], VisitStack[][]>>((acc, v) => {
         const path = v.path.map(f => ({ ...f }));
         for (const ev of v.fields) {
           acc[ev.type].push([...rootStack, ...path, { ...(ev.type === 'removing' ? ev.prev : ev.curr)! }]);
         }
         return acc;
-      }, { added: [], changed: [], removing: [] } as Record<ChangeEvent<unknown>['type'], VisitStack[][]>);
+      }, { added: [], changed: [], removing: [] });
 
       await Promise.all(changes.added.map(v => this.#dialect.executeSQL(this.#dialect.getAddColumnSQL(v))));
       await Promise.all(changes.changed.map(v => this.#dialect.executeSQL(this.#dialect.getModifyColumnSQL(v))));
       await Promise.all(changes.removing.map(v => this.#dialect.executeSQL(this.#dialect.getDropColumnSQL(v))));
-    } catch (e) {
+    } catch (err) {
       // Failed to change
-      console.error('Unable to change field', { error: e });
+      console.error('Unable to change field', { error: err });
     }
   }
 }