metal-orm 1.0.41 → 1.0.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {
@@ -28,7 +28,9 @@
     "gen:entities": "node scripts/generate-entities.mjs",
     "test": "vitest",
     "test:ui": "vitest --ui",
-    "show-sql": "node scripts/show-sql.mjs"
+    "show-sql": "node scripts/show-sql.mjs",
+    "lint": "node scripts/run-eslint.mjs",
+    "lint:fix": "node scripts/run-eslint.mjs --fix"
   },
   "peerDependencies": {
     "mysql2": "^3.9.0",
@@ -52,6 +54,10 @@
   },
   "devDependencies": {
     "@vitest/ui": "^4.0.14",
+    "@typescript-eslint/eslint-plugin": "^8.20.0",
+    "@typescript-eslint/parser": "^8.20.0",
+    "eslint": "^8.57.0",
+    "eslint-plugin-deprecation": "^3.0.0",
     "mysql2": "^3.15.3",
     "pg": "^8.16.3",
     "sqlite3": "^5.1.7",

package/scripts/run-eslint.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+const [, , ...userArgs] = process.argv;
+
+const TARGETS = {
+    src: ['./src'],
+    all: ['./src', './tests', './scripts', './playground'],
+    playground: ['./playground'],
+    'src/core': ['./src/core'],
+};
+
+const [firstArg, ...restArgs] = userArgs;
+const hasTarget = firstArg && !firstArg.startsWith('-');
+
+const targetKey = hasTarget ? firstArg : 'all';
+const extraArgs = hasTarget ? restArgs : userArgs;
+
+const paths = TARGETS[targetKey] ?? [targetKey];
+
+if (paths.length === 0) {
+    console.error(`Unknown lint target: ${targetKey}`);
+    process.exit(1);
+}
+
+const eslintArgs = [...paths, '--ext', '.ts,.tsx,.mjs', ...extraArgs];
+
+const eslintBinBase = path.join(process.cwd(), 'node_modules', '.bin', 'eslint');
+const executable = process.platform === 'win32' ? `${eslintBinBase}.cmd` : eslintBinBase;
+
+const child = spawn(executable, eslintArgs, { stdio: 'inherit', shell: true });
+
+child.on('exit', (code) => process.exit(code));

package/src/codegen/typescript.ts

@@ -1,4 +1,4 @@
-import { SelectQueryNode } from '../core/ast/query.js';
+import { OrderingTerm, SelectQueryNode } from '../core/ast/query.js';
 import {
   ExpressionNode,
   OperandNode,
@@ -36,8 +36,15 @@ const assertNever = (value: never): never => {
 /**
  * Generates TypeScript code from query AST nodes
  */
+type SelectionColumn =
+  | ColumnNode
+  | FunctionNode
+  | ScalarSubqueryNode
+  | CaseExpressionNode
+  | WindowFunctionNode;
+
 export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVisitor<string> {
-  constructor(private namingStrategy: NamingStrategy = new DefaultNamingStrategy()) {}
+  constructor(private namingStrategy: NamingStrategy = new DefaultNamingStrategy()) { }
 
   /**
    * Generates TypeScript code from a query AST
@@ -62,12 +69,8 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
     const hydratedRelations = new Set(hydration?.relations?.map(r => r.name) ?? []);
 
     const selections = ast.columns
-      .filter(col => !(hydration && isRelationAlias((col as any).alias)))
-      .map(col => {
-        const key = (col as any).alias || (col as any).name;
-        const operand = col as OperandNode;
-        return `${key}: ${this.printOperand(operand)}`;
-      });
+      .filter((col): col is SelectionColumn => !(hydration && isRelationAlias(col.alias)))
+      .map((col, index) => `${this.getSelectionKey(col, index)}: ${this.printOperand(col)}`);
 
     lines.push(`db.select({`);
     selections.forEach((sel, index) => {
@@ -168,26 +171,40 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
   /**
    * Prints an ordering term (operand/expression/alias) to TypeScript code.
    */
-  private printOrderingTerm(term: any): string {
-    if (!term || !(term as any).type) {
+  private printOrderingTerm(term: OrderingTerm): string {
+    if (!term || !('type' in term)) {
       throw new Error('Unsupported ordering term');
     }
 
-    switch ((term as any).type) {
+    switch (term.type) {
       case 'Column':
-        return `${this.namingStrategy.tableToSymbol((term as any).table)}.${(term as any).name}`;
+        return `${this.namingStrategy.tableToSymbol(term.table)}.${term.name}`;
       case 'AliasRef':
-        return this.visitAliasRef(term as any);
+        return this.visitAliasRef(term);
       case 'Literal':
       case 'Function':
       case 'JsonPath':
       case 'ScalarSubquery':
       case 'CaseExpression':
       case 'WindowFunction':
-        return this.printOperand(term as OperandNode);
+        return this.printOperand(term);
       default:
-        return this.printExpression(term as ExpressionNode);
+        return this.printExpression(term);
+    }
+  }
+
+  private getSelectionKey(selection: SelectionColumn, index: number): string {
+    if (selection.alias) {
+      return selection.alias;
+    }
+    if (this.isNamedSelection(selection)) {
+      return selection.name;
     }
+    return `selection${index + 1}`;
+  }
+
+  private isNamedSelection(selection: SelectionColumn): selection is ColumnNode | FunctionNode | WindowFunctionNode {
+    return 'name' in selection;
   }
 
   public visitBinaryExpression(binary: BinaryExpressionNode): string {

package/src/core/ast/builders.ts

@@ -1,4 +1,4 @@
-import { ColumnNode } from './expression-nodes.js';
+import { ColumnNode, OperandNode } from './expression-nodes.js';
 import { TableNode, FunctionTableNode, DerivedTableNode } from './query.js';
 import { ColumnRef, TableRef } from './types.js';
 
@@ -50,7 +50,12 @@ export const createTableNode = (table: TableRef): TableNode => ({
 /**
  * Creates a FunctionTable node for expressions like `function_name(args...)` used in FROM
  */
-export const fnTable = (name: string, args: any[] = [], alias?: string, opts?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }): FunctionTableNode => ({
+export const fnTable = (
+  name: string,
+  args: OperandNode[] = [],
+  alias?: string,
+  opts?: { lateral?: boolean; withOrdinality?: boolean; columnAliases?: string[]; schema?: string }
+): FunctionTableNode => ({
   type: 'FunctionTable',
   name,
   args,

package/src/core/ast/expression-builders.ts

@@ -3,12 +3,10 @@ import { SqlOperator } from '../sql/sql.js';
 import { ColumnRef } from './types.js';
 import {
   ColumnNode,
-  FunctionNode,
   LiteralNode,
   JsonPathNode,
   OperandNode,
   CaseExpressionNode,
-  WindowFunctionNode,
   BinaryExpressionNode,
   ExpressionNode,
   LogicalExpressionNode,

package/src/core/ast/expression-nodes.ts

@@ -146,11 +146,20 @@ const operandTypes = new Set<OperandNode['type']>([
   'WindowFunction'
 ]);
 
-export const isOperandNode = (node: any): node is OperandNode => node && operandTypes.has(node.type);
-
-export const isFunctionNode = (node: any): node is FunctionNode => node?.type === 'Function';
-export const isCaseExpressionNode = (node: any): node is CaseExpressionNode => node?.type === 'CaseExpression';
-export const isWindowFunctionNode = (node: any): node is WindowFunctionNode => node?.type === 'WindowFunction';
+const hasTypeProperty = (value: unknown): value is { type?: string } =>
+  typeof value === 'object' && value !== null && 'type' in value;
+
+export const isOperandNode = (node: unknown): node is OperandNode => {
+  if (!hasTypeProperty(node)) return false;
+  return operandTypes.has(node.type as OperandNode['type']);
+};
+
+export const isFunctionNode = (node: unknown): node is FunctionNode =>
+  isOperandNode(node) && node.type === 'Function';
+export const isCaseExpressionNode = (node: unknown): node is CaseExpressionNode =>
+  isOperandNode(node) && node.type === 'CaseExpression';
+export const isWindowFunctionNode = (node: unknown): node is WindowFunctionNode =>
+  isOperandNode(node) && node.type === 'WindowFunction';
 export const isExpressionSelectionNode = (
   node: ColumnRef | FunctionNode | CaseExpressionNode | WindowFunctionNode
 ): node is FunctionNode | CaseExpressionNode | WindowFunctionNode =>

package/src/core/ast/expression-visitor.ts

@@ -47,8 +47,8 @@ export interface OperandVisitor<R> {
   otherwise?(node: OperandNode): R;
 }
 
-type ExpressionDispatch = <R>(node: any, visitor: ExpressionVisitor<R>) => R;
-type OperandDispatch = <R>(node: any, visitor: OperandVisitor<R>) => R;
+type ExpressionDispatch = <R>(node: ExpressionNode, visitor: ExpressionVisitor<R>) => R;
+type OperandDispatch = <R>(node: OperandNode, visitor: OperandVisitor<R>) => R;
 
 const expressionDispatchers = new Map<string, ExpressionDispatch>();
 const operandDispatchers = new Map<string, OperandDispatch>();
@@ -75,12 +75,15 @@ export const registerOperandDispatcher = (type: string, dispatcher: OperandDispa
 export const clearExpressionDispatchers = (): void => expressionDispatchers.clear();
 export const clearOperandDispatchers = (): void => operandDispatchers.clear();
 
+const getNodeType = (node: { type?: string } | null | undefined): string | undefined =>
+  typeof node === 'object' && node !== null && typeof node.type === 'string' ? node.type : undefined;
+
 const unsupportedExpression = (node: ExpressionNode): never => {
-  throw new Error(`Unsupported expression type "${(node as any)?.type ?? 'unknown'}"`);
+  throw new Error(`Unsupported expression type "${getNodeType(node) ?? 'unknown'}"`);
 };
 
 const unsupportedOperand = (node: OperandNode): never => {
-  throw new Error(`Unsupported operand type "${(node as any)?.type ?? 'unknown'}"`);
+  throw new Error(`Unsupported operand type "${getNodeType(node) ?? 'unknown'}"`);
 };
 /**
  * Dispatches an expression node to the visitor
@@ -88,8 +91,8 @@ const unsupportedOperand = (node: OperandNode): never => {
  * @param visitor - Visitor implementation
  */
 export const visitExpression = <R>(node: ExpressionNode, visitor: ExpressionVisitor<R>): R => {
-  const dynamic = expressionDispatchers.get((node as any)?.type);
-  if (dynamic) return dynamic(node as any, visitor);
+  const dynamic = expressionDispatchers.get(node.type);
+  if (dynamic) return dynamic(node, visitor);
 
   switch (node.type) {
     case 'BinaryExpression':
@@ -126,8 +129,8 @@ export const visitExpression = <R>(node: ExpressionNode, visitor: ExpressionVisi
  * @param visitor - Visitor implementation
  */
 export const visitOperand = <R>(node: OperandNode, visitor: OperandVisitor<R>): R => {
-  const dynamic = operandDispatchers.get((node as any)?.type);
-  if (dynamic) return dynamic(node as any, visitor);
+  const dynamic = operandDispatchers.get(node.type);
+  if (dynamic) return dynamic(node, visitor);
 
   switch (node.type) {
     case 'Column':

package/src/core/ast/expression.ts

@@ -1,7 +1,7 @@
-export * from './expression-nodes.js';
+export * from './expression-nodes.js';
 export * from './expression-builders.js';
 export * from './window-functions.js';
 export * from './aggregate-functions.js';
 export * from './expression-visitor.js';
-export * from './types.js';
+export type { ColumnRef, TableRef as AstTableRef } from './types.js';
 export * from './adapters.js';

package/src/core/ast/join-node.ts

@@ -2,7 +2,7 @@ import { JoinNode } from './join.js';
 import { ExpressionNode } from './expression.js';
 import { JoinKind } from '../sql/sql.js';
 import { JoinMetadata } from './join-metadata.js';
-import { TableSourceNode, TableNode, FunctionTableNode } from './query.js';
+import { TableSourceNode, TableNode } from './query.js';
 
 /**
  * Creates a JoinNode ready for AST insertion.

package/src/core/ast/query.ts

@@ -1,12 +1,12 @@
 import {
+  AliasRefNode,
+  CaseExpressionNode,
   ColumnNode,
-  FunctionNode,
   ExpressionNode,
-  ScalarSubqueryNode,
-  CaseExpressionNode,
-  WindowFunctionNode,
+  FunctionNode,
   OperandNode,
-  AliasRefNode
+  ScalarSubqueryNode,
+  WindowFunctionNode
 } from './expression.js';
 import { JoinNode } from './join.js';
 import { OrderDirection } from '../sql/sql.js';
@@ -34,7 +34,7 @@ export interface FunctionTableNode {
   /** Optional schema for the function (some dialects) */
   schema?: string;
   /** Function arguments as operand nodes */
-  args?: any[]; // use any to avoid circular import here; caller should supply OperandNode
+  args?: OperandNode[];
   /** Optional alias for the function table */
   alias?: string;
   /** LATERAL flag */

package/src/core/ast/window-functions.ts

@@ -60,7 +60,11 @@ export const ntile = (n: number): WindowFunctionNode =>
  * @param defaultValue - Default value if no row exists
  * @returns Window function node for LAG
  */
-export const lag = (col: ColumnRef | ColumnNode, offset: number = 1, defaultValue?: any): WindowFunctionNode => {
+export const lag = (
+  col: ColumnRef | ColumnNode,
+  offset: number = 1,
+  defaultValue?: LiteralNode['value']
+): WindowFunctionNode => {
   const args: (ColumnNode | LiteralNode | JsonPathNode)[] = [
     columnOperand(col),
     { type: 'Literal', value: offset }
@@ -78,7 +82,11 @@ export const lag = (col: ColumnRef | ColumnNode, offset: number = 1, defaultValu
  * @param defaultValue - Default value if no row exists
  * @returns Window function node for LEAD
  */
-export const lead = (col: ColumnRef | ColumnNode, offset: number = 1, defaultValue?: any): WindowFunctionNode => {
+export const lead = (
+  col: ColumnRef | ColumnNode,
+  offset: number = 1,
+  defaultValue?: LiteralNode['value']
+): WindowFunctionNode => {
   const args: (ColumnNode | LiteralNode | JsonPathNode)[] = [
     columnOperand(col),
     { type: 'Literal', value: offset }

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

@@ -1,5 +1,5 @@
 import { SchemaDialect, DialectName } from '../schema-dialect.js';
-import { formatLiteral, quoteQualified, createLiteralFormatter, LiteralFormatter } from '../sql-writing.js';
+import { formatLiteral, quoteQualified, LiteralFormatter } from '../sql-writing.js';
 import { ColumnDef, ForeignKeyReference } from '../../../schema/column.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
 import { DatabaseTable, DatabaseColumn, ColumnDiff } from '../schema-types.js';
@@ -29,16 +29,26 @@ export abstract class BaseSchemaDialect implements SchemaDialect {
   abstract get literalFormatter(): LiteralFormatter;
 
   renderDefault(value: unknown, _column: ColumnDef): string {
+    void _column;
     return formatLiteral(this.literalFormatter, value);
   }
   renderReference(ref: ForeignKeyReference, _table: TableDef): string {
+    void _table;
     const parts = ['REFERENCES', quoteQualified(this, ref.table), `(${this.quoteIdentifier(ref.column)})`];
     if (ref.onDelete) parts.push('ON DELETE', ref.onDelete);
     if (ref.onUpdate) parts.push('ON UPDATE', ref.onUpdate);
-    if (ref.deferrable && this.name === 'postgres') parts.push('DEFERRABLE INITIALLY DEFERRED');
+    const suffix = this.renderReferenceSuffix(ref, _table);
+    if (suffix) parts.push(suffix);
     return parts.join(' ');
   }
+
+  protected renderReferenceSuffix(ref: ForeignKeyReference, _table: TableDef): string | undefined {
+    void ref;
+    void _table;
+    return undefined;
+  }
   renderTableOptions(_table: TableDef): string | undefined {
+    void _table;
     return undefined;
   }
   dropTableSql(table: DatabaseTable): string[] {
@@ -51,12 +61,29 @@ export abstract class BaseSchemaDialect implements SchemaDialect {
     return [`DROP INDEX ${this.quoteIdentifier(index)};`];
   }
   warnDropColumn(_table: DatabaseTable, _column: string): string | undefined {
+    void _table;
+    void _column;
     return undefined;
   }
-  alterColumnSql?(table: TableDef, column: ColumnDef, actualColumn: DatabaseColumn, diff: ColumnDiff): string[] {
+  alterColumnSql?(_table: TableDef, _column: ColumnDef, _actualColumn: DatabaseColumn, _diff: ColumnDiff): string[] {
+    void _table;
+    void _column;
+    void _actualColumn;
+    void _diff;
     return [];
   }
   warnAlterColumn?(_table: TableDef, _column: ColumnDef, _actual: DatabaseColumn, _diff: ColumnDiff): string | undefined {
+    void _table;
+    void _column;
+    void _actual;
+    void _diff;
     return undefined;
   }
+
+  preferInlinePkAutoincrement(_column: ColumnDef, _table: TableDef, _pk: string[]): boolean {
+    void _column;
+    void _table;
+    void _pk;
+    return false;
+  }
 }

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

@@ -120,6 +120,7 @@ export class MSSqlSchemaDialect extends BaseSchemaDialect {
   }
 
   alterColumnSql(table: TableDef, column: ColumnDef, _actual: DatabaseColumn, diff: ColumnDiff): string[] {
+    void _actual;
     const stmts: string[] = [];
     if (diff.typeChanged || diff.nullabilityChanged) {
       const nullability = column.notNull ? 'NOT NULL' : 'NULL';
@@ -131,6 +132,9 @@ export class MSSqlSchemaDialect extends BaseSchemaDialect {
   }
 
   warnAlterColumn(_table: TableDef, _column: ColumnDef, _actual: DatabaseColumn, diff: ColumnDiff): string | undefined {
+    void _table;
+    void _column;
+    void _actual;
     if (diff.defaultChanged || diff.autoIncrementChanged) {
       return 'Altering defaults or identity on MSSQL is not automated (requires dropping/adding default or identity constraints manually).';
     }

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

@@ -125,6 +125,8 @@ export class MySqlSchemaDialect extends BaseSchemaDialect {
   }
 
   alterColumnSql(table: TableDef, column: ColumnDef, _actual: DatabaseColumn, _diff: ColumnDiff): string[] {
+    void _actual;
+    void _diff;
     const rendered = renderColumnDefinition(table, column, this);
     return [`ALTER TABLE ${this.formatTableName(table)} MODIFY COLUMN ${rendered.sql};`];
   }

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

@@ -1,7 +1,7 @@
 import { BaseSchemaDialect } from './base-schema-dialect.js';
 import { deriveIndexName } from '../naming-strategy.js';
 import { renderIndexColumns, createLiteralFormatter } from '../sql-writing.js';
-import { ColumnDef } from '../../../schema/column.js';
+import { ColumnDef, ForeignKeyReference } from '../../../schema/column.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
 import { ColumnDiff, DatabaseColumn, DatabaseTable } from '../schema-types.js';
 import { DialectName } from '../schema-dialect.js';
@@ -102,6 +102,14 @@ export class PostgresSchemaDialect extends BaseSchemaDialect {
     return true;
   }
 
+  protected renderReferenceSuffix(ref: ForeignKeyReference, _table: TableDef): string | undefined {
+    void _table;
+    if (ref.deferrable) {
+      return 'DEFERRABLE INITIALLY DEFERRED';
+    }
+    return undefined;
+  }
+
   dropColumnSql(table: DatabaseTable, column: string): string[] {
     return [`ALTER TABLE ${this.formatTableName(table)} DROP COLUMN ${this.quoteIdentifier(column)};`];
   }
@@ -114,6 +122,7 @@ export class PostgresSchemaDialect extends BaseSchemaDialect {
   }
 
   alterColumnSql(table: TableDef, column: ColumnDef, actualColumn: DatabaseColumn, diff: ColumnDiff): string[] {
+    void actualColumn;
     const stmts: string[] = [];
     const tableName = this.formatTableName(table);
     const colName = this.quoteIdentifier(column.name);
@@ -145,6 +154,9 @@ export class PostgresSchemaDialect extends BaseSchemaDialect {
   }
 
   warnAlterColumn(_table: TableDef, _column: ColumnDef, _actual: DatabaseColumn, diff: ColumnDiff): string | undefined {
+    void _table;
+    void _column;
+    void _actual;
     if (diff.autoIncrementChanged) {
       return 'Altering identity properties may fail if an existing sequence is attached; verify generated column state.';
     }

package/src/core/ddl/dialects/render-reference.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest';
+import { BaseSchemaDialect } from './base-schema-dialect.js';
+import { PostgresSchemaDialect } from './postgres-schema-dialect.js';
+import { TableDef } from '../../../schema/table.js';
+import { ForeignKeyReference } from '../../../schema/column.js';
+import { createLiteralFormatter } from '../sql-writing.js';
+
+class DummySchemaDialect extends BaseSchemaDialect {
+    readonly name = 'sqlite';
+    private readonly formatter = createLiteralFormatter({
+        booleanTrue: '1',
+        booleanFalse: '0',
+    });
+
+    get literalFormatter() {
+        return this.formatter;
+    }
+
+    quoteIdentifier(id: string): string {
+        return `"${id}"`;
+    }
+
+    renderColumnType(): string {
+        return 'INTEGER';
+    }
+
+    renderAutoIncrement(): string | undefined {
+        return undefined;
+    }
+
+    renderIndex(): string {
+        return 'CREATE INDEX dummy;';
+    }
+}
+
+const table: TableDef = {
+    name: 'child',
+    columns: {},
+    relations: {},
+};
+
+const deferrableReference: ForeignKeyReference = {
+    table: 'parent',
+    column: 'id',
+    deferrable: true,
+    onDelete: 'CASCADE',
+    onUpdate: 'NO ACTION',
+};
+
+describe('renderReference deferrable handling', () => {
+    it('base dialect remains agnostic to deferrable flags', () => {
+        const dialect = new DummySchemaDialect();
+        const sql = dialect.renderReference(deferrableReference, table);
+        expect(sql).toContain('REFERENCES "parent"');
+        expect(sql).not.toContain('DEFERRABLE INITIALLY DEFERRED');
+    });
+
+    it('Postgres dialect renders the deferrable clause', () => {
+        const dialect = new PostgresSchemaDialect();
+        const sql = dialect.renderReference(deferrableReference, table);
+        expect(sql).toContain('DEFERRABLE INITIALLY DEFERRED');
+    });
+
+    it('Postgres dialect skips the clause when the flag is missing', () => {
+        const dialect = new PostgresSchemaDialect();
+        const sql = dialect.renderReference({ table: 'parent', column: 'id' }, table);
+        expect(sql).not.toContain('DEFERRABLE INITIALLY DEFERRED');
+    });
+});

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

@@ -103,10 +103,13 @@ export class SQLiteSchemaDialect extends BaseSchemaDialect {
   }
 
   dropColumnSql(_table: DatabaseTable, _column: string): string[] {
+    void _table;
+    void _column;
     return [];
   }
 
   dropIndexSql(_table: DatabaseTable, index: string): string[] {
+    void _table;
     return [`DROP INDEX IF EXISTS ${this.quoteIdentifier(index)};`];
   }
 
@@ -116,10 +119,16 @@ export class SQLiteSchemaDialect extends BaseSchemaDialect {
   }
 
   alterColumnSql(_table: TableDef, _column: ColumnDef, _actual: DatabaseColumn, _diff: ColumnDiff): string[] {
+    void _table;
+    void _column;
+    void _actual;
+    void _diff;
     return [];
   }
 
   warnAlterColumn(table: TableDef, column: ColumnDef, _actual: DatabaseColumn, _diff: ColumnDiff): string | undefined {
+    void _actual;
+    void _diff;
     const key = table.schema ? `${table.schema}.${table.name}` : table.name;
     return `SQLite ALTER COLUMN is not supported; rebuild table ${key} to change column ${column.name}.`;
   }