metal-orm 1.0.42 → 1.0.44

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

@@ -3,13 +3,58 @@ import { queryRows, shouldIncludeTable } from './utils.js';
 import { DatabaseSchema, DatabaseTable, DatabaseIndex, DatabaseColumn } from '../schema-types.js';
 import { DbExecutor } from '../../execution/db-executor.js';
 
+/** Row type for MSSQL column information. */
+type MssqlColumnRow = {
+  table_schema: string;
+  table_name: string;
+  column_name: string;
+  data_type: string;
+  is_nullable: boolean | number;
+  is_identity: boolean | number;
+  column_default: string | null;
+};
+
+/** Row type for MSSQL primary key information. */
+type MssqlPrimaryKeyRow = {
+  table_schema: string;
+  table_name: string;
+  column_name: string;
+  key_ordinal: number;
+};
+
+/** Row type for MSSQL index information. */
+type MssqlIndexRow = {
+  table_schema: string;
+  table_name: string;
+  index_name: string;
+  is_unique: boolean | number;
+  has_filter: boolean | number;
+  filter_definition: string | null;
+};
+
+/** Row type for MSSQL index column information. */
+type MssqlIndexColumnRow = {
+  table_schema: string;
+  table_name: string;
+  index_name: string;
+  column_name: string;
+  key_ordinal: number;
+};
+
+/** MSSQL schema introspector implementation. */
 export const mssqlIntrospector: SchemaIntrospector = {
+  /**
+   * Introspects the MSSQL database schema.
+   * @param ctx - The introspection context containing the database executor.
+   * @param options - Options for introspection, such as schema filter.
+   * @returns A promise that resolves to the introspected database schema.
+   */
   async introspect(ctx: { executor: DbExecutor }, options: IntrospectOptions): Promise<DatabaseSchema> {
     const schema = options.schema;
     const filterSchema = schema ? 'sch.name = @p1' : '1=1';
     const params = schema ? [schema] : [];
 
-    const columnRows = await queryRows(
+    const columnRows = (await queryRows(
       ctx.executor,
       `
       SELECT
@@ -27,9 +72,9 @@ export const mssqlIntrospector: SchemaIntrospector = {
       WHERE t.is_ms_shipped = 0 AND ${filterSchema}
       `,
       params
-    );
+    )) as MssqlColumnRow[];
 
-    const pkRows = await queryRows(
+    const pkRows = (await queryRows(
       ctx.executor,
       `
       SELECT
@@ -46,7 +91,7 @@ export const mssqlIntrospector: SchemaIntrospector = {
       ORDER BY ic.key_ordinal
       `,
       params
-    );
+    )) as MssqlPrimaryKeyRow[];
 
     const pkMap = new Map<string, string[]>();
     pkRows.forEach(r => {
@@ -56,7 +101,7 @@ export const mssqlIntrospector: SchemaIntrospector = {
       pkMap.set(key, list);
     });
 
-    const indexRows = await queryRows(
+    const indexRows = (await queryRows(
       ctx.executor,
       `
       SELECT
@@ -72,9 +117,9 @@ export const mssqlIntrospector: SchemaIntrospector = {
       WHERE i.is_primary_key = 0 AND i.is_hypothetical = 0 AND ${filterSchema}
       `,
       params
-    );
+    )) as MssqlIndexRow[];
 
-    const indexColsRows = await queryRows(
+    const indexColsRows = (await queryRows(
       ctx.executor,
       `
       SELECT
@@ -92,7 +137,7 @@ export const mssqlIntrospector: SchemaIntrospector = {
       ORDER BY ic.key_ordinal
       `,
       params
-    );
+    )) as MssqlIndexColumnRow[];
 
     const indexColumnsMap = new Map<string, { column: string; order: number }[]>();
     indexColsRows.forEach(r => {

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

@@ -3,13 +3,39 @@ import { queryRows, shouldIncludeTable } from './utils.js';
 import { DatabaseSchema, DatabaseTable, DatabaseIndex, DatabaseColumn } from '../schema-types.js';
 import { DbExecutor } from '../../execution/db-executor.js';
 
+/** Row type for MySQL column information. */
+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;
+};
+
+/** MySQL schema introspector. */
 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 +44,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 +55,7 @@ export const mysqlIntrospector: SchemaIntrospector = {
       ORDER BY ordinal_position
       `,
       params
-    );
+    )) as MysqlPrimaryKeyRow[];
 
     const pkMap = new Map<string, string[]>();
     pkRows.forEach(r => {
@@ -39,7 +65,7 @@ export const mysqlIntrospector: SchemaIntrospector = {
       pkMap.set(key, list);
     });
 
-    const indexRows = await queryRows(
+    const indexRows = (await queryRows(
       ctx.executor,
       `
       SELECT
@@ -53,7 +79,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,81 @@ import type { ColumnNode, ExpressionNode } from '../../ast/expression-nodes.js';
 import { fnTable } from '../../ast/builders.js';
 import { runSelect, runSelectNode } from './run-select.js';
 
+/** Row type for PostgreSQL column introspection from information_schema.columns. */
+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;
+};
+
+/** Row type for PostgreSQL primary key introspection from key_column_usage and table_constraints. */
+type PrimaryKeyIntrospectRow = {
+  table_schema: string;
+  table_name: string;
+  column_name: string;
+  ordinal_position: number | null;
+  constraint_name: string;
+};
+
+/** Row type for PostgreSQL foreign key introspection from various constraint tables. */
+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;
+};
+
+/** Represents a foreign key reference entry with optional referential actions. */
+type ForeignKeyEntry = {
+  table: string;
+  column: string;
+  onDelete?: ReferentialAction;
+  onUpdate?: ReferentialAction;
+};
+
+/** Row type for PostgreSQL index query results from pg_catalog tables. */
+type IndexQueryRow = {
+  table_schema: string;
+  table_name: string;
+  index_name: string;
+  is_unique: boolean;
+  predicate: string | null;
+  attname: string | null;
+  ord: number | null;
+};
+
+/** Grouped index information used for aggregating index columns. */
+type IndexGroup = {
+  table_schema: string;
+  table_name: string;
+  index_name: string;
+  is_unique: boolean;
+  predicate: string | null;
+  cols: { ord: number; att: string | null }[];
+};
+
+/** PostgreSQL schema introspector. */
 export const postgresIntrospector: SchemaIntrospector = {
+  /**
+   * Introspects the PostgreSQL database schema by querying information_schema and pg_catalog.
+   * Builds tables with columns, primary keys, foreign keys, and indexes.
+   * @param ctx - The introspection context with database executor.
+   * @param options - Options for schema selection and table filtering.
+   * @returns A promise resolving to the complete database schema.
+   */
   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 +101,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 +112,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 +135,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 +145,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 +206,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 +226,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 +283,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/registry.ts

@@ -5,8 +5,12 @@ import { mysqlIntrospector } from './mysql.js';
 import { sqliteIntrospector } from './sqlite.js';
 import { mssqlIntrospector } from './mssql.js';
 
+/** Registry mapping dialect names to their corresponding schema introspectors. */
 const registry = new Map<DialectName, SchemaIntrospector>();
 
+/**
+ * Registers the built-in schema introspectors for all supported database dialects.
+ */
 const registerBuiltInIntrospectors = () => {
   registry.set('postgres', postgresIntrospector);
   registry.set('mysql', mysqlIntrospector);
@@ -16,10 +20,20 @@ const registerBuiltInIntrospectors = () => {
 
 registerBuiltInIntrospectors();
 
+/**
+ * Registers a schema introspector for a dialect.
+ * @param dialect - The dialect name.
+ * @param introspector - The schema introspector.
+ */
 export const registerSchemaIntrospector = (dialect: DialectName, introspector: SchemaIntrospector): void => {
   registry.set(dialect, introspector);
 };
 
+/**
+ * Gets the schema introspector for a dialect.
+ * @param dialect - The dialect name.
+ * @returns The schema introspector or undefined if not found.
+ */
 export const getSchemaIntrospector = (dialect: DialectName): SchemaIntrospector | undefined => {
   return registry.get(dialect);
 };

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

@@ -1,10 +1,19 @@
-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>,
+/** A source that can provide a select query AST. */
+type SelectQuerySource = { getAST(): SelectQueryNode };
+
+/**
+ * Runs a select query from a query builder and returns the results.
+ * @param qb - The query builder.
+ * @param ctx - The introspection context.
+ * @returns The query results.
+ */
+export async function runSelect<T = Record<string, unknown>>(
+  qb: SelectQuerySource,
   ctx: IntrospectContext
 ): Promise<T[]> {
   const ast = qb.getAST();
@@ -17,7 +26,13 @@ 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[]> {
+/**
+ * Runs a select query from an AST node and returns the results.
+ * @param ast - The select query AST.
+ * @param ctx - The introspection context.
+ * @returns The query results.
+ */
+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,91 @@
 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';
 
+/** Row type for SQLite table list from sqlite_master. */
+type SqliteTableRow = {
+  name: string;
+};
+
+/** Row type for SQLite table column information from PRAGMA table_info. */
+type SqliteTableInfoRow = {
+  name: string;
+  type: string;
+  notnull: number;
+  dflt_value: string | null;
+  pk: number;
+};
+
+/** Row type for SQLite foreign key information from PRAGMA foreign_key_list. */
+type SqliteForeignKeyRow = {
+  table: string;
+  from: string;
+  to: string;
+  on_delete: string | null;
+  on_update: string | null;
+};
+
+/** Row type for SQLite index list from PRAGMA index_list. */
+type SqliteIndexListRow = {
+  name: string;
+  unique: number;
+};
+
+/** Row type for SQLite index column information from PRAGMA index_info. */
+type SqliteIndexInfoRow = {
+  name: string;
+};
+
+/**
+ * Converts a SQLite referential action string to a ReferentialAction enum value.
+ * @param value - The string value from SQLite pragma (e.g., 'CASCADE', 'SET NULL').
+ * @returns The corresponding ReferentialAction enum value, or undefined if the value is invalid or null.
+ */
+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;
+};
+
+/**
+ * Escapes single quotes in a string for safe inclusion in SQL queries.
+ * @param name - The string to escape.
+ * @returns The escaped string with single quotes doubled.
+ */
 const escapeSingleQuotes = (name: string) => name.replace(/'/g, "''");
 
+/** SQLite schema introspector. */
 export const sqliteIntrospector: SchemaIntrospector = {
+  /**
+   * Introspects the SQLite database schema by querying sqlite_master and various PRAGMAs.
+   * @param ctx - The database execution context containing the DbExecutor.
+   * @param options - Options controlling which tables and schemas to include.
+   * @returns A promise that resolves to the introspected DatabaseSchema.
+   */
   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 +100,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,25 +1,43 @@
 import { DbExecutor, QueryResult } from '../../execution/db-executor.js';
 import { IntrospectOptions } from './types.js';
 
-export const toRows = (result: QueryResult | undefined): Record<string, any>[] => {
+/**
+ * Converts a query result to an array of row objects.
+ * @param result - The query result.
+ * @returns The array of rows.
+ */
+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;
     }, {})
   );
 };
 
+/**
+ * Executes a SQL query and returns the rows.
+ * @param executor - The database executor.
+ * @param sql - The SQL query.
+ * @param params - The query parameters.
+ * @returns The array of rows.
+ */
 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);
 };
 
+/**
+ * Checks if a table should be included in introspection based on options.
+ * @param name - The table name.
+ * @param options - The introspection options.
+ * @returns True if the table should be included.
+ */
 export const shouldIncludeTable = (name: string, options: IntrospectOptions): boolean => {
   if (options.includeTables && !options.includeTables.includes(name)) return false;
   if (options.excludeTables && options.excludeTables.includes(name)) return false;

package/src/core/ddl/naming-strategy.ts

@@ -1,5 +1,11 @@
 import type { TableDef, IndexDef } from '../../schema/table.js';
 
+/**
+ * Derives the name for an index based on the table and index definition.
+ * @param table - The table definition.
+ * @param index - The index definition.
+ * @returns The derived index name.
+ */
 export const deriveIndexName = (table: TableDef, index: IndexDef): string => {
   const base = (index.columns ?? [])
     .map(col => (typeof col === 'string' ? col : col.column))