@travetto/model-sql 2.1.5 → 2.2.2

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,15 +46,17 @@ 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)) {
-      for (const k of Object.keys(o) as (keyof T)[]) {
+      for (const k of Object.keys(o)) {
         if (o[k] === null || o[k] === undefined || k === dct.parentPathField.name || k === dct.pathField.name || k === dct.idxField.name) {
           delete o[k];
         } else {
           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 +64,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 +73,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 +99,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 +117,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 +145,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 +173,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 +184,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 +208,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 +221,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 +229,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 +263,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 +274,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 +299,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 +311,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 +322,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 +330,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 });
     }
   }
 }