metal-orm 1.0.42 → 1.0.43

package/src/core/ddl/introspect/mysql.ts

@@ -3,13 +3,37 @@ import { queryRows, shouldIncludeTable } from './utils.js';
 import { DatabaseSchema, DatabaseTable, DatabaseIndex, DatabaseColumn } from '../schema-types.js';
 import { DbExecutor } from '../../execution/db-executor.js';
 
+type MysqlColumnRow = {
+  table_schema: string;
+  table_name: string;
+  column_name: string;
+  data_type: string;
+  is_nullable: string;
+  column_default: string | null;
+  extra: string | null;
+};
+
+type MysqlPrimaryKeyRow = {
+  table_schema: string;
+  table_name: string;
+  column_name: string;
+};
+
+type MysqlIndexRow = {
+  table_schema: string;
+  table_name: string;
+  index_name: string;
+  non_unique: number;
+  cols: string | null;
+};
+
 export const mysqlIntrospector: SchemaIntrospector = {
   async introspect(ctx: { executor: DbExecutor }, options: IntrospectOptions): Promise<DatabaseSchema> {
     const schema = options.schema;
     const filterClause = schema ? 'table_schema = ?' : 'table_schema = database()';
     const params = schema ? [schema] : [];
 
-    const columnRows = await queryRows(
+    const columnRows = (await queryRows(
       ctx.executor,
       `
       SELECT table_schema, table_name, column_name, data_type, is_nullable, column_default, extra
@@ -18,9 +42,9 @@ export const mysqlIntrospector: SchemaIntrospector = {
       ORDER BY table_name, ordinal_position
       `,
       params
-    );
+    )) as MysqlColumnRow[];
 
-    const pkRows = await queryRows(
+    const pkRows = (await queryRows(
       ctx.executor,
       `
       SELECT table_schema, table_name, column_name
@@ -29,7 +53,7 @@ export const mysqlIntrospector: SchemaIntrospector = {
       ORDER BY ordinal_position
       `,
       params
-    );
+    )) as MysqlPrimaryKeyRow[];
 
     const pkMap = new Map<string, string[]>();
     pkRows.forEach(r => {
@@ -39,7 +63,7 @@ export const mysqlIntrospector: SchemaIntrospector = {
       pkMap.set(key, list);
     });
 
-    const indexRows = await queryRows(
+    const indexRows = (await queryRows(
       ctx.executor,
       `
       SELECT
@@ -53,7 +77,7 @@ export const mysqlIntrospector: SchemaIntrospector = {
       GROUP BY table_schema, table_name, index_name, non_unique
       `,
       params
-    );
+    )) as MysqlIndexRow[];
 
     const tablesByKey = new Map<string, DatabaseTable>();
 

package/src/core/ddl/introspect/postgres.ts

@@ -1,10 +1,10 @@
 import type { SchemaIntrospector, IntrospectOptions } from './types.js';
-import { queryRows, shouldIncludeTable } from './utils.js';
+import { shouldIncludeTable } from './utils.js';
 import { DatabaseSchema, DatabaseTable, DatabaseIndex, DatabaseColumn } from '../schema-types.js';
-import type { DbExecutor } from '../../execution/db-executor.js';
+import type { ReferentialAction } from '../../../schema/column.js';
 import type { IntrospectContext } from './context.js';
 import { PgInformationSchemaColumns } from './catalogs/postgres.js';
-import { PgKeyColumnUsage, PgTableConstraints, PgConstraintColumnUsage, PgReferentialConstraints, PgIndex, PgClass, PgNamespace, PgAttribute } from './catalogs/postgres.js';
+import { PgKeyColumnUsage, PgTableConstraints, PgConstraintColumnUsage, PgReferentialConstraints } from './catalogs/postgres.js';
 import { SelectQueryBuilder } from '../../../query-builder/select.js';
 import { eq, and } from '../../ast/expression-builders.js';
 import type { SelectQueryNode, TableNode } from '../../ast/query.js';
@@ -13,13 +13,67 @@ import type { ColumnNode, ExpressionNode } from '../../ast/expression-nodes.js';
 import { fnTable } from '../../ast/builders.js';
 import { runSelect, runSelectNode } from './run-select.js';
 
+type ColumnIntrospectRow = {
+  table_schema: string;
+  table_name: string;
+  column_name: string;
+  data_type: string;
+  is_nullable: string;
+  column_default: string | null;
+  ordinal_position: number | null;
+};
+
+type PrimaryKeyIntrospectRow = {
+  table_schema: string;
+  table_name: string;
+  column_name: string;
+  ordinal_position: number | null;
+  constraint_name: string;
+};
+
+type ForeignKeyIntrospectRow = {
+  table_schema: string;
+  table_name: string;
+  column_name: string;
+  constraint_name: string;
+  foreign_table_schema: string;
+  foreign_table_name: string;
+  foreign_column_name: string;
+};
+
+type ForeignKeyEntry = {
+  table: string;
+  column: string;
+  onDelete?: ReferentialAction;
+  onUpdate?: ReferentialAction;
+};
+
+type IndexQueryRow = {
+  table_schema: string;
+  table_name: string;
+  index_name: string;
+  is_unique: boolean;
+  predicate: string | null;
+  attname: string | null;
+  ord: number | null;
+};
+
+type IndexGroup = {
+  table_schema: string;
+  table_name: string;
+  index_name: string;
+  is_unique: boolean;
+  predicate: string | null;
+  cols: { ord: number; att: string | null }[];
+};
+
 export const postgresIntrospector: SchemaIntrospector = {
   async introspect(ctx: IntrospectContext, options: IntrospectOptions): Promise<DatabaseSchema> {
     const schema = options.schema || 'public';
     const tables: DatabaseTable[] = [];
 
     // Columns query
-    const qbColumns = new SelectQueryBuilder(PgInformationSchemaColumns as any)
+    const qbColumns = new SelectQueryBuilder(PgInformationSchemaColumns)
       .select({
         table_schema: PgInformationSchemaColumns.columns.table_schema,
         table_name: PgInformationSchemaColumns.columns.table_name,
@@ -33,10 +87,10 @@ export const postgresIntrospector: SchemaIntrospector = {
       .orderBy(PgInformationSchemaColumns.columns.table_name)
       .orderBy(PgInformationSchemaColumns.columns.ordinal_position);
 
-    const columnRows = await runSelect(qbColumns, ctx);
+    const columnRows = await runSelect<ColumnIntrospectRow>(qbColumns, ctx);
 
     // Primary key columns query
-    const qbPk = new SelectQueryBuilder(PgKeyColumnUsage as any)
+    const qbPk = new SelectQueryBuilder(PgKeyColumnUsage)
       .select({
         table_schema: PgKeyColumnUsage.columns.table_schema,
         table_name: PgKeyColumnUsage.columns.table_name,
@@ -44,13 +98,13 @@ export const postgresIntrospector: SchemaIntrospector = {
         ordinal_position: PgKeyColumnUsage.columns.ordinal_position,
         constraint_name: PgKeyColumnUsage.columns.constraint_name
       })
-      .innerJoin(PgTableConstraints as any, eq(PgTableConstraints.columns.constraint_name, PgKeyColumnUsage.columns.constraint_name))
+      .innerJoin(PgTableConstraints, eq(PgTableConstraints.columns.constraint_name, PgKeyColumnUsage.columns.constraint_name))
       .where(eq(PgTableConstraints.columns.constraint_type, 'PRIMARY KEY'))
       .where(eq(PgKeyColumnUsage.columns.table_schema, schema))
       .orderBy(PgKeyColumnUsage.columns.table_name)
       .orderBy(PgKeyColumnUsage.columns.ordinal_position);
 
-    const pkRows = await runSelect(qbPk, ctx);
+    const pkRows = await runSelect<PrimaryKeyIntrospectRow>(qbPk, ctx);
 
     // Build primary key map (grouped by table, ordered by ordinal_position)
     const pkMap = new Map<string, string[]>();
@@ -67,7 +121,7 @@ export const postgresIntrospector: SchemaIntrospector = {
     }
 
     // Foreign key columns query
-    const qbFk = new SelectQueryBuilder(PgKeyColumnUsage as any)
+    const qbFk = new SelectQueryBuilder(PgKeyColumnUsage)
       .select({
         table_schema: PgKeyColumnUsage.columns.table_schema,
         table_name: PgKeyColumnUsage.columns.table_name,
@@ -77,16 +131,16 @@ export const postgresIntrospector: SchemaIntrospector = {
         foreign_table_name: PgConstraintColumnUsage.columns.table_name,
         foreign_column_name: PgConstraintColumnUsage.columns.column_name
       })
-      .innerJoin(PgTableConstraints as any, eq(PgTableConstraints.columns.constraint_name, PgKeyColumnUsage.columns.constraint_name))
-      .innerJoin(PgConstraintColumnUsage as any, eq(PgConstraintColumnUsage.columns.constraint_name, PgTableConstraints.columns.constraint_name))
-      .innerJoin(PgReferentialConstraints as any, eq(PgReferentialConstraints.columns.constraint_name, PgTableConstraints.columns.constraint_name))
+      .innerJoin(PgTableConstraints, eq(PgTableConstraints.columns.constraint_name, PgKeyColumnUsage.columns.constraint_name))
+      .innerJoin(PgConstraintColumnUsage, eq(PgConstraintColumnUsage.columns.constraint_name, PgTableConstraints.columns.constraint_name))
+      .innerJoin(PgReferentialConstraints, eq(PgReferentialConstraints.columns.constraint_name, PgTableConstraints.columns.constraint_name))
       .where(eq(PgTableConstraints.columns.constraint_type, 'FOREIGN KEY'))
       .where(eq(PgKeyColumnUsage.columns.table_schema, schema));
 
-    const fkRows = await runSelect(qbFk, ctx);
+    const fkRows = await runSelect<ForeignKeyIntrospectRow>(qbFk, ctx);
 
     // Build foreign key map
-    const fkMap = new Map<string, any[]>();
+    const fkMap = new Map<string, ForeignKeyEntry[]>();
     for (const r of fkRows) {
       const key = `${r.table_schema}.${r.table_name}.${r.column_name}`;
       const existing = fkMap.get(key) ?? [];
@@ -138,10 +192,10 @@ export const postgresIntrospector: SchemaIntrospector = {
         {
           type: 'Join',
           kind: 'INNER',
-          table: fnTable('unnest', [{ type: 'Column', table: 'i', name: 'indkey' } as ColumnNode], 'arr', { 
-            lateral: true, 
-            withOrdinality: true, 
-            columnAliases: ['attnum', 'idx'] 
+          table: fnTable('unnest', [{ type: 'Column', table: 'i', name: 'indkey' } as ColumnNode], 'arr', {
+            lateral: true,
+            withOrdinality: true,
+            columnAliases: ['attnum', 'idx']
           }),
           condition: { type: 'BinaryExpression', left: { type: 'Literal', value: 1 }, operator: '=', right: { type: 'Literal', value: 1 } } as unknown as ExpressionNode
         } as JoinNode,
@@ -158,23 +212,23 @@ export const postgresIntrospector: SchemaIntrospector = {
       ],
       where: and(
         eq({ table: 'ns', name: 'nspname' }, schema) as ExpressionNode,
-        eq({ table: 'i', name: 'indisprimary' }, { type: 'Literal', value: false } as any) as ExpressionNode
+        eq({ table: 'i', name: 'indisprimary' }, false) as ExpressionNode
       ) as ExpressionNode
     };
 
-    const indexQueryRows = await runSelectNode(indexQuery, ctx);
-    
+    const indexQueryRows = await runSelectNode<IndexQueryRow>(indexQuery, ctx);
+
     // Aggregate index rows by table/index to build final index list
-    const indexGrouped = new Map<string, { table_schema: string; table_name: string; index_name: string; is_unique: any; predicate: any; cols: { ord: number; att: string | null }[] }>();
+    const indexGrouped = new Map<string, IndexGroup>();
     for (const r of indexQueryRows) {
       const key = `${r.table_schema}.${r.table_name}.${r.index_name}`;
-      const entry = indexGrouped.get(key) ?? { 
-        table_schema: r.table_schema, 
-        table_name: r.table_name, 
-        index_name: r.index_name, 
-        is_unique: r.is_unique, 
-        predicate: r.predicate, 
-        cols: [] 
+      const entry = indexGrouped.get(key) ?? {
+        table_schema: r.table_schema,
+        table_name: r.table_name,
+        index_name: r.index_name,
+        is_unique: r.is_unique,
+        predicate: r.predicate,
+        cols: []
       };
       entry.cols.push({ ord: r.ord ?? 0, att: r.attname ?? null });
       indexGrouped.set(key, entry);
@@ -215,11 +269,11 @@ export const postgresIntrospector: SchemaIntrospector = {
         default: r.column_default ?? undefined,
         references: fk
           ? {
-              table: fk.table,
-              column: fk.column,
-              onDelete: fk.onDelete,
-              onUpdate: fk.onUpdate
-            }
+            table: fk.table,
+            column: fk.column,
+            onDelete: fk.onDelete,
+            onUpdate: fk.onUpdate
+          }
           : undefined
       };
       cols.columns.push(column);

package/src/core/ddl/introspect/run-select.ts

@@ -1,10 +1,12 @@
-import type { SelectQueryBuilder } from '../../../query-builder/select.js';
 import type { IntrospectContext } from './context.js';
+import type { SelectQueryNode } from '../../ast/query.js';
 
 import { toRows } from './utils.js';
 
-export async function runSelect<T = Record<string, any>>(
-  qb: SelectQueryBuilder<any, any>,
+type SelectQuerySource = { getAST(): SelectQueryNode };
+
+export async function runSelect<T = Record<string, unknown>>(
+  qb: SelectQuerySource,
   ctx: IntrospectContext
 ): Promise<T[]> {
   const ast = qb.getAST();
@@ -17,7 +19,7 @@ export async function runSelect<T = Record<string, any>>(
 
 export default runSelect;
 
-export async function runSelectNode<T = Record<string, any>>(ast: any, ctx: IntrospectContext): Promise<T[]> {
+export async function runSelectNode<T = Record<string, unknown>>(ast: SelectQueryNode, ctx: IntrospectContext): Promise<T[]> {
   const compiled = ctx.dialect.compileSelect(ast);
   const results = await ctx.executor.executeSql(compiled.sql, compiled.params);
   const [first] = results;

package/src/core/ddl/introspect/sqlite.ts

@@ -1,24 +1,69 @@
 import { SchemaIntrospector, IntrospectOptions } from './types.js';
 import { queryRows, shouldIncludeTable } from './utils.js';
 import { DatabaseSchema, DatabaseTable, DatabaseIndex } from '../schema-types.js';
+import { ReferentialAction } from '../../../schema/column.js';
 import { DbExecutor } from '../../execution/db-executor.js';
 
+type SqliteTableRow = {
+  name: string;
+};
+
+type SqliteTableInfoRow = {
+  name: string;
+  type: string;
+  notnull: number;
+  dflt_value: string | null;
+  pk: number;
+};
+
+type SqliteForeignKeyRow = {
+  table: string;
+  from: string;
+  to: string;
+  on_delete: string | null;
+  on_update: string | null;
+};
+
+type SqliteIndexListRow = {
+  name: string;
+  unique: number;
+};
+
+type SqliteIndexInfoRow = {
+  name: string;
+};
+
+const toReferentialAction = (value: string | null | undefined): ReferentialAction | undefined => {
+  if (!value) return undefined;
+  const normalized = value.toUpperCase();
+  if (
+    normalized === 'NO ACTION' ||
+    normalized === 'RESTRICT' ||
+    normalized === 'CASCADE' ||
+    normalized === 'SET NULL' ||
+    normalized === 'SET DEFAULT'
+  ) {
+    return normalized as ReferentialAction;
+  }
+  return undefined;
+};
+
 const escapeSingleQuotes = (name: string) => name.replace(/'/g, "''");
 
 export const sqliteIntrospector: SchemaIntrospector = {
   async introspect(ctx: { executor: DbExecutor }, options: IntrospectOptions): Promise<DatabaseSchema> {
     const tables: DatabaseTable[] = [];
-    const tableRows = await queryRows(
+    const tableRows = (await queryRows(
       ctx.executor,
       `SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%';`
-    );
+    )) as SqliteTableRow[];
 
     for (const row of tableRows) {
-      const name = row.name as string;
+      const name = row.name;
       if (!shouldIncludeTable(name, options)) continue;
       const table: DatabaseTable = { name, columns: [], primaryKey: [], indexes: [] };
 
-      const cols = await queryRows(ctx.executor, `PRAGMA table_info('${escapeSingleQuotes(name)}');`);
+      const cols = (await queryRows(ctx.executor, `PRAGMA table_info('${escapeSingleQuotes(name)}');`)) as SqliteTableInfoRow[];
       cols.forEach(c => {
         table.columns.push({
           name: c.name,
@@ -33,26 +78,26 @@ export const sqliteIntrospector: SchemaIntrospector = {
         }
       });
 
-      const fkRows = await queryRows(ctx.executor, `PRAGMA foreign_key_list('${escapeSingleQuotes(name)}');`);
+      const fkRows = (await queryRows(ctx.executor, `PRAGMA foreign_key_list('${escapeSingleQuotes(name)}');`)) as SqliteForeignKeyRow[];
       fkRows.forEach(fk => {
         const col = table.columns.find(c => c.name === fk.from);
         if (col) {
           col.references = {
             table: fk.table,
             column: fk.to,
-            onDelete: fk.on_delete?.toUpperCase(),
-            onUpdate: fk.on_update?.toUpperCase()
+            onDelete: toReferentialAction(fk.on_delete),
+            onUpdate: toReferentialAction(fk.on_update)
           };
         }
       });
 
-      const idxList = await queryRows(ctx.executor, `PRAGMA index_list('${escapeSingleQuotes(name)}');`);
+      const idxList = (await queryRows(ctx.executor, `PRAGMA index_list('${escapeSingleQuotes(name)}');`)) as SqliteIndexListRow[];
       for (const idx of idxList) {
-        const idxName = idx.name as string;
-        const columnsInfo = await queryRows(ctx.executor, `PRAGMA index_info('${escapeSingleQuotes(idxName)}');`);
+        const idxName = idx.name;
+        const columnsInfo = (await queryRows(ctx.executor, `PRAGMA index_info('${escapeSingleQuotes(idxName)}');`)) as SqliteIndexInfoRow[];
         const idxEntry: DatabaseIndex = {
           name: idxName,
-          columns: columnsInfo.map(ci => ({ column: ci.name as string })),
+          columns: columnsInfo.map(ci => ({ column: ci.name })),
           unique: idx.unique === 1
         };
         table.indexes!.push(idxEntry);

package/src/core/ddl/introspect/types.ts

@@ -1,4 +1,3 @@
-import type { DbExecutor } from '../../execution/db-executor.js';
 import { DatabaseSchema } from '../schema-types.js';
 import type { IntrospectContext } from './context.js';
 

package/src/core/ddl/introspect/utils.ts

@@ -1,10 +1,10 @@
 import { DbExecutor, QueryResult } from '../../execution/db-executor.js';
 import { IntrospectOptions } from './types.js';
 
-export const toRows = (result: QueryResult | undefined): Record<string, any>[] => {
+export const toRows = (result: QueryResult | undefined): Record<string, unknown>[] => {
   if (!result) return [];
   return result.values.map(row =>
-    result.columns.reduce<Record<string, any>>((acc, col, idx) => {
+    result.columns.reduce<Record<string, unknown>>((acc, col, idx) => {
       acc[col] = row[idx];
       return acc;
     }, {})
@@ -15,7 +15,7 @@ export const queryRows = async (
   executor: DbExecutor,
   sql: string,
   params: unknown[] = []
-): Promise<Record<string, any>[]> => {
+): Promise<Record<string, unknown>[]> => {
   const [first] = await executor.executeSql(sql, params);
   return toRows(first);
 };

package/src/core/ddl/schema-dialect.ts

@@ -30,6 +30,7 @@ export interface SchemaDialect {
 
   // Capability flags
   supportsPartialIndexes(): boolean;
+  preferInlinePkAutoincrement(column: ColumnDef, table: TableDef, pk: string[]): boolean;
 
   // DDL operations
   dropColumnSql?(table: DatabaseTable, column: string): string[];

package/src/core/ddl/schema-generator.ts

@@ -1,15 +1,7 @@
-import type { TableDef, IndexDef, IndexColumn } from '../../schema/table.js';
-import type { ColumnDef, ForeignKeyReference } from '../../schema/column.js';
+import type { TableDef } from '../../schema/table.js';
+import type { ColumnDef } from '../../schema/column.js';
 import type { SchemaDialect } from './schema-dialect.js';
-import { deriveIndexName } from './naming-strategy.js';
-import {
-  formatLiteral,
-  renderIndexColumns,
-  quoteQualified,
-  resolvePrimaryKey,
-  Quoter
-} from './sql-writing.js';
-import { DatabaseTable, DatabaseColumn, ColumnDiff } from './schema-types.js';
+import { resolvePrimaryKey } from './sql-writing.js';
 import { DialectName } from './schema-dialect.js';
 
 export interface SchemaGenerateResult {
@@ -60,7 +52,7 @@ export const generateCreateTableSql = (
   const inlinePkColumns = new Set<string>();
 
   const columnLines = Object.values(table.columns).map(col => {
-    const includePk = (dialect as any).preferInlinePkAutoincrement?.(col, table, pk) && pk.includes(col.name);
+    const includePk = dialect.preferInlinePkAutoincrement(col, table, pk) && pk.includes(col.name);
     if (includePk) {
       inlinePkColumns.add(col.name);
     }

package/src/core/ddl/sql-writing.ts

@@ -1,5 +1,5 @@
 import type { TableDef, IndexColumn } from '../../schema/table.js';
-import type { RawDefaultValue } from '../../schema/column.js';
+import type { ColumnDef, RawDefaultValue } from '../../schema/column.js';
 
 /**
  * Minimal surface for anything that can quote identifiers.
@@ -161,10 +161,10 @@ export const resolvePrimaryKey = (table: TableDef): string[] => {
     return table.primaryKey;
   }
 
-  const columns = Object.values(table.columns ?? {});
+  const columns = Object.values(table.columns ?? {}) as ColumnDef[];
 
   // `primary` / `name` are domain-level properties of ColumnDef.
   return columns
-    .filter((col: any) => col.primary)
-    .map((col: any) => col.name);
+    .filter(col => col.primary)
+    .map(col => col.name);
 };

package/src/core/dialect/abstract.ts

@@ -157,8 +157,9 @@ export abstract class Dialect
 
   protected compileReturning(
     returning: ColumnNode[] | undefined,
-    ctx: CompilerContext
+    _ctx: CompilerContext
   ): string {
+    void _ctx;
     if (!returning || returning.length === 0) return '';
     throw new Error('RETURNING is not supported by this dialect.');
   }
@@ -213,7 +214,8 @@ export abstract class Dialect
    * @param index - Parameter index
    * @returns Formatted placeholder string
    */
-  protected formatPlaceholder(index: number): string {
+  protected formatPlaceholder(_index: number): string {
+    void _index;
     return '?';
   }
 
@@ -221,7 +223,8 @@ export abstract class Dialect
    * Whether the current dialect supports a given set operation.
    * Override in concrete dialects to restrict support.
    */
-  protected supportsSetOperation(kind: SetOperationKind): boolean {
+  protected supportsSetOperation(_kind: SetOperationKind): boolean {
+    void _kind;
     return true;
   }
 
@@ -376,6 +379,7 @@ export abstract class Dialect
     if (isOperandNode(term)) {
       return this.compileOperand(term, ctx);
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const expr = this.compileExpression(term as any, ctx);
     return `(${expr})`;
   }
@@ -438,15 +442,22 @@ export abstract class Dialect
   private registerDefaultOperandCompilers(): void {
     this.registerOperandCompiler('Literal', (literal: LiteralNode, ctx) => ctx.addParameter(literal.value));
 
-    this.registerOperandCompiler('AliasRef', (alias: AliasRefNode, _ctx) => this.quoteIdentifier(alias.name));
+    this.registerOperandCompiler('AliasRef', (alias: AliasRefNode, _ctx) => {
+      void _ctx;
+      return this.quoteIdentifier(alias.name);
+    });
 
     this.registerOperandCompiler('Column', (column: ColumnNode, _ctx) => {
+      void _ctx;
       return `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`;
     });
     this.registerOperandCompiler('Function', (fnNode: FunctionNode, ctx) =>
       this.compileFunctionOperand(fnNode, ctx)
     );
-    this.registerOperandCompiler('JsonPath', (path: JsonPathNode, _ctx) => this.compileJsonPath(path));
+    this.registerOperandCompiler('JsonPath', (path: JsonPathNode, _ctx) => {
+      void _ctx;
+      return this.compileJsonPath(path);
+    });
 
     this.registerOperandCompiler('ScalarSubquery', (node: ScalarSubqueryNode, ctx) => {
       const sql = this.compileSelectAst(node.query, ctx).trim().replace(/;$/, '');
@@ -499,7 +510,8 @@ export abstract class Dialect
   }
 
   // Default fallback, should be overridden by dialects if supported
-  protected compileJsonPath(node: JsonPathNode): string {
+  protected compileJsonPath(_node: JsonPathNode): string {
+    void _node;
     throw new Error("JSON Path not supported by this dialect");
   }
 

package/src/core/dialect/base/function-table-formatter.ts

@@ -1,4 +1,5 @@
 import { CompilerContext } from '../abstract.js';
+import { OperandNode } from '../../ast/expression.js';
 import { SqlDialectBase } from './sql-dialect.js';
 
 export interface FunctionTableNode {
@@ -57,9 +58,9 @@ export class FunctionTableFormatter {
    */
   private static formatArgs(fn: FunctionTableNode, ctx?: CompilerContext, dialect?: SqlDialectBase): string {
     return (fn.args || [])
-      .map((a: any) => {
+      .map((a: OperandNode) => {
         if (ctx && dialect) {
-          return (dialect as any).compileOperand(a, ctx);
+          return (dialect as unknown as { compileOperand(n: OperandNode, c: CompilerContext): string }).compileOperand(a, ctx);
         }
         return String(a);
       })

package/src/core/dialect/base/join-compiler.ts

@@ -1,5 +1,7 @@
 import { CompilerContext } from '../abstract.js';
 import { JoinNode } from '../../ast/join.js';
+import { TableSourceNode } from '../../ast/query.js';
+import { ExpressionNode } from '../../ast/expression.js';
 
 /**
  * Compiler for JOIN clauses in SELECT statements.
@@ -9,12 +11,12 @@ export class JoinCompiler {
   static compileJoins(
     joins: JoinNode[] | undefined,
     ctx: CompilerContext,
-    compileFrom: (from: any, ctx: CompilerContext) => string,
-    compileExpression: (expr: any, ctx: CompilerContext) => string
+    compileFrom: (from: TableSourceNode, ctx: CompilerContext) => string,
+    compileExpression: (expr: ExpressionNode, ctx: CompilerContext) => string
   ): string {
     if (!joins || joins.length === 0) return '';
     const parts = joins.map(j => {
-      const table = compileFrom(j.table as any, ctx);
+      const table = compileFrom(j.table, ctx);
       const cond = compileExpression(j.condition, ctx);
       return `${j.kind} JOIN ${table} ON ${cond}`;
     });

package/src/core/dialect/base/returning-strategy.ts

@@ -35,6 +35,7 @@ export class NoReturningStrategy implements ReturningStrategy {
    * @throws Error indicating RETURNING is not supported.
    */
   compileReturning(returning: ColumnNode[] | undefined, _ctx: CompilerContext): string {
+    void _ctx;
     if (!returning || returning.length === 0) return '';
     throw new Error('RETURNING is not supported by this dialect.');
   }

package/src/core/dialect/base/sql-dialect.ts

@@ -11,7 +11,7 @@ import {
   OrderByNode,
   TableNode
 } from '../../ast/query.js';
-import { ColumnNode } from '../../ast/expression.js';
+import { ColumnNode, OperandNode } from '../../ast/expression.js';
 import { FunctionTableFormatter } from './function-table-formatter.js';
 import { PaginationStrategy, StandardLimitOffsetPagination } from './pagination-strategy.js';
 import { CteCompiler } from './cte-compiler.js';
@@ -134,7 +134,7 @@ export abstract class SqlDialectBase extends Dialect {
   }
 
   private compileUpdateAssignments(
-    assignments: { column: ColumnNode; value: any }[],
+    assignments: { column: ColumnNode; value: OperandNode }[],
     table: TableNode,
     ctx: CompilerContext
   ): string {
@@ -190,7 +190,7 @@ export abstract class SqlDialectBase extends Dialect {
   }
 
   protected compileFrom(ast: SelectQueryNode['from'], ctx?: CompilerContext): string {
-    const tableSource = ast as any;
+    const tableSource = ast;
     if (tableSource.type === 'FunctionTable') {
       return this.compileFunctionTable(tableSource, ctx);
     }