uql-orm 0.66.0 → 0.67.1

package/dist/migrate/ddl/pgIndexDdl.d.ts

@@ -15,24 +15,14 @@ export declare class PgIndexDdl extends IndexDdl {
     protected isVectorIndex(index: IndexSchema): boolean;
     protected indexAccessMethod(index: IndexSchema): string;
     /**
-     * A vector index's operator class is named `{type}_{metric}_ops`: an index on a `halfvec` column
-     * needs `halfvec_cosine_ops`, and `vector_cosine_ops` there is rejected outright. An unsupported
-     * distance throws rather than being omitted, since a bare `USING hnsw ("embedding")` would build
-     * with the dialect's default metric instead of the one requested, with nothing signalling it.
-     * Everything else takes the operator class the entry declares, e.g. `jsonb_path_ops` for GIN.
+     * A vector index's operator class, `{type}_{metric}_ops` (`halfvec_cosine_ops`), refusing a metric it
+     * lacks rather than build with the default; any other entry takes the class it declares.
      */
     protected indexColumnOpsClass(entry: IndexColumnSchema, index: IndexSchema): string;
     protected indexInclude(index: IndexSchema): string;
     protected indexTuning(index: IndexSchema): string;
 }
-/**
- * CockroachDB's vector index is native and has its own syntax: `CREATE VECTOR INDEX ... ("col"
- * vector_cosine_ops)`, with no access-method keyword, and tuning knobs of its own names that UQL
- * does not map. `type: 'vector'` is its trigger, the same generic value MariaDB's index uses.
- *
- * `NULLS FIRST/LAST` answers "unimplemented: this syntax" and `jsonb_path_ops` "operator class is
- * not supported" (both verified on v26.2), so neither is offered here.
- */
+/** CockroachDB's native `CREATE VECTOR INDEX`, for `type: 'vector'`; it has neither `NULLS FIRST/LAST` nor `jsonb_path_ops`. */
 export declare class CockroachIndexDdl extends PgIndexDdl {
     protected readonly indexFeatures: Set<"expression" | "include" | "jsonArray" | "jsonPath" | "nullsOrder" | "opsClass" | "partial" | "prefixLength">;
     /** v26.3 answers `hash` and `brin` "unimplemented", `ivfflat` "unrecognized"; `hnsw` builds its vector index. */

package/dist/migrate/ddl/pgIndexDdl.js

@@ -36,11 +36,8 @@ export class PgIndexDdl extends IndexDdl {
         return index.type ? ` USING ${index.type}` : '';
     }
     /**
-     * A vector index's operator class is named `{type}_{metric}_ops`: an index on a `halfvec` column
-     * needs `halfvec_cosine_ops`, and `vector_cosine_ops` there is rejected outright. An unsupported
-     * distance throws rather than being omitted, since a bare `USING hnsw ("embedding")` would build
-     * with the dialect's default metric instead of the one requested, with nothing signalling it.
-     * Everything else takes the operator class the entry declares, e.g. `jsonb_path_ops` for GIN.
+     * A vector index's operator class, `{type}_{metric}_ops` (`halfvec_cosine_ops`), refusing a metric it
+     * lacks rather than build with the default; any other entry takes the class it declares.
      */
     indexColumnOpsClass(entry, index) {
         if (!this.isVectorIndex(index) || !index.distance) {
@@ -77,14 +74,7 @@ export class PgIndexDdl extends IndexDdl {
         return params.length > 0 ? ` WITH (${params.join(', ')})` : '';
     }
 }
-/**
- * CockroachDB's vector index is native and has its own syntax: `CREATE VECTOR INDEX ... ("col"
- * vector_cosine_ops)`, with no access-method keyword, and tuning knobs of its own names that UQL
- * does not map. `type: 'vector'` is its trigger, the same generic value MariaDB's index uses.
- *
- * `NULLS FIRST/LAST` answers "unimplemented: this syntax" and `jsonb_path_ops` "operator class is
- * not supported" (both verified on v26.2), so neither is offered here.
- */
+/** CockroachDB's native `CREATE VECTOR INDEX`, for `type: 'vector'`; it has neither `NULLS FIRST/LAST` nor `jsonb_path_ops`. */
 export class CockroachIndexDdl extends PgIndexDdl {
     indexFeatures = new Set(['expression', 'partial', 'include', 'jsonPath']);
     /** v26.3 answers `hash` and `brin` "unimplemented", `ivfflat` "unrecognized"; `hnsw` builds its vector index. */

package/dist/migrate/generator/definitionToNode.d.ts

@@ -9,15 +9,8 @@ import type { FullColumnDefinition, IndexDefinition, TableDefinition } from '../
  */
 export declare function tableDefinitionToNode(def: TableDefinition, render: (sql: QueryRaw) => string): TableNode;
 /**
- * A builder's column as the AST node the generators render from.
- *
- * The shared half is spread, not copied field by field: `ColumnDefinition` *is* a `ColumnNode` minus
- * the graph links, so spreading it and adding those back is a node by construction. Listed one by one,
- * the copy silently dropped whatever the node gained next - `enum` first, and the type had no way to
- * say so. The two builder-only keys are destructured off: `index` and `foreignKey` are lifted onto the
- * table by `columnIndex`/`columnForeignKey`, which is the path that renders them.
- *
- * No `references` node either: `SchemaAST.addRelationship` sets that one.
+ * A builder's column as the node the generators render, spread so a field the node gains carries over.
+ * `index` and `foreignKey` are lifted onto the table elsewhere; `addRelationship` sets `references`.
  */
 export declare function fullColumnDefinitionToNode(col: FullColumnDefinition, tableName: string): ColumnNode;
 /**

package/dist/migrate/generator/definitionToNode.js

@@ -1,13 +1,6 @@
 import { renderIndexColumn } from '../../util/ddlExpression.util.js';
 import { derivedForeignKeyName, derivedIndexName } from '../../util/sql.util.js';
-/**
- * A table the builder names but has not seen.
- *
- * A `RelationshipNode` points at a whole `TableNode` because the AST wires `incomingRelations` through
- * it; a builder creating one table has no node for the table its foreign key targets, and the
- * generator reads only the name. Stated once, so the three casts it replaces cannot be mistaken for a
- * node that was resolved and lost.
- */
+/** A table the builder names but has not seen, which the generator reads only the name of. */
 function unresolvedTable(name) {
     return { name };
 }
@@ -63,15 +56,8 @@ export function tableDefinitionToNode(def, render) {
     return table;
 }
 /**
- * A builder's column as the AST node the generators render from.
- *
- * The shared half is spread, not copied field by field: `ColumnDefinition` *is* a `ColumnNode` minus
- * the graph links, so spreading it and adding those back is a node by construction. Listed one by one,
- * the copy silently dropped whatever the node gained next - `enum` first, and the type had no way to
- * say so. The two builder-only keys are destructured off: `index` and `foreignKey` are lifted onto the
- * table by `columnIndex`/`columnForeignKey`, which is the path that renders them.
- *
- * No `references` node either: `SchemaAST.addRelationship` sets that one.
+ * A builder's column as the node the generators render, spread so a field the node gains carries over.
+ * `index` and `foreignKey` are lifted onto the table elsewhere; `addRelationship` sets `references`.
  */
 export function fullColumnDefinitionToNode(col, tableName) {
     const { index: _index, foreignKey: _foreignKey, ...column } = col;

package/dist/migrate/generator/indexNodeToSchema.d.ts

@@ -2,8 +2,7 @@ import type { IndexNode } from '../../schema/types.js';
 import type { IndexSchema } from '../../type/index.js';
 /**
  * An AST index as the generators and dialects want it. Spread rather than copied field by field:
- * rebuilding it by hand is how the partial-index `where` once vanished without a trace. The node-only
- * keys (`table`, `source`, `syncStatus`) are ignored downstream, and the vector type travels along
- * because pgvector's operator-class names are built from it.
+ * rebuilding it by hand is how the partial-index `where` once vanished without a trace. Its `table` is
+ * ignored downstream, and the vector type travels along because pgvector's operator-class names are built from it.
  */
 export declare function indexNodeToSchema(index: IndexNode): IndexSchema;

package/dist/migrate/generator/indexNodeToSchema.js

@@ -2,9 +2,8 @@ import { isVectorCategory } from '../../schema/canonicalType.js';
 import { indexColumns } from '../../schema/indexColumns.js';
 /**
  * An AST index as the generators and dialects want it. Spread rather than copied field by field:
- * rebuilding it by hand is how the partial-index `where` once vanished without a trace. The node-only
- * keys (`table`, `source`, `syncStatus`) are ignored downstream, and the vector type travels along
- * because pgvector's operator-class names are built from it.
+ * rebuilding it by hand is how the partial-index `where` once vanished without a trace. Its `table` is
+ * ignored downstream, and the vector type travels along because pgvector's operator-class names are built from it.
  */
 export function indexNodeToSchema(index) {
     return {

package/dist/migrate/generator/mongoCommand.d.ts

@@ -6,14 +6,7 @@ export type MongoIndexOptions = {
     readonly name: string;
     readonly partialFilterExpression?: Readonly<Record<string, unknown>>;
 };
-/**
- * `SchemaGenerator` yields one string per statement, so {@link MongoSchemaGenerator} emits its
- * commands as JSON and this is their schema.
- *
- * Declared next to the generator that writes them because the migrator used to restate the shape
- * inline from `JSON.parse`, with `cmd.name!` assertions and a bare `action: string` - where a command
- * it had no branch for was silently a no-op.
- */
+/** The commands {@link MongoSchemaGenerator} emits as JSON, one per statement. */
 export type MongoCommand = {
     readonly action: 'createCollection';
     readonly name: string;

package/dist/migrate/generator/mongoSchemaGenerator.d.ts

@@ -33,14 +33,7 @@ export declare class MongoSchemaGenerator extends MongoDialect implements Schema
     generateDropTable(tableName: string): string;
     generateAlterTable(diff: SchemaDiff): string[];
     generateAlterTableDown(diff: SchemaDiff): string[];
-    /**
-     * MongoDB's key spec is where its index options live: `-1` for a descending entry and `'text'` for a
-     * full-text index, which is what `$text` needs since a text index declares its own fields.
-     *
-     * @remarks The SQL-only options are refused by the checks the SQL dialects refuse each other's with - a
-     * silently weaker index is worse than a clear failure. `where` is the filter's JSON, as
-     * {@link compileIndexPredicate} writes it.
-     */
+    /** An index as MongoDB's key spec (`-1` descending, `'text'` full-text), refusing the SQL-only options. */
     generateCreateIndex(tableName: string, index: IndexSchema): string;
     generateDropIndex(tableName: string, indexName: string): string;
     /** A collection and its indexes, which is all a document store has: a column, a constraint or SQL throws. */

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -96,14 +96,7 @@ export class MongoSchemaGenerator extends MongoDialect {
     generateAlterTableDown(diff) {
         return (diff.indexesToAdd ?? []).map((index) => this.generateDropIndex(diff.tableName, index.name));
     }
-    /**
-     * MongoDB's key spec is where its index options live: `-1` for a descending entry and `'text'` for a
-     * full-text index, which is what `$text` needs since a text index declares its own fields.
-     *
-     * @remarks The SQL-only options are refused by the checks the SQL dialects refuse each other's with - a
-     * silently weaker index is worse than a clear failure. `where` is the filter's JSON, as
-     * {@link compileIndexPredicate} writes it.
-     */
+    /** An index as MongoDB's key spec (`-1` descending, `'text'` full-text), refusing the SQL-only options. */
     generateCreateIndex(tableName, index) {
         assertIndexType(index, MONGO_INDEX_TYPES, this.dialectName);
         assertIndexFeatures(index, MONGO_INDEX_FEATURES, this.dialectName);

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.d.ts

@@ -1,4 +1,4 @@
-import type { ForeignKeyAction } from '../../schema/types.js';
+import { type ForeignKeyAction } from '../../schema/types.js';
 import type { ColumnSchema, ForeignKeySchema, IndexSchema, QuerierPool, RawRow, SchemaIntrospector, SqlQuerier, TableSchema } from '../../type/index.js';
 import { BaseSqlIntrospector } from './baseSqlIntrospector.js';
 /**
@@ -12,32 +12,14 @@ import { BaseSqlIntrospector } from './baseSqlIntrospector.js';
  * it is four avoidable ones.
  */
 export type TableRowReader = <T extends RawRow>(sql: string, params?: unknown[]) => Promise<T[]>;
-/**
- * Abstract base class for SQL schema introspectors.
- *
- * Uses the template-method pattern to consolidate shared logic while allowing
- * dialect-specific implementations for SQL queries and type normalization.
- *
- * Subclasses must implement:
- * - `getTableNamesQuery()` - SQL to list all table names
- * - `tableExistsQuery()` - SQL to check if a table exists
- * - `getColumnsQuery()` - SQL to get column metadata
- * - `getIndexesQuery()` - SQL to get index metadata
- * - `getForeignKeysQuery()` - SQL to get foreign key metadata
- * - `getPrimaryKeyQuery()` - SQL to get primary key columns
- * - `mapColumnRow()` - Map a column query result row to ColumnSchema
- * - `mapIndexRow()` - Map an index query result row to IndexSchema
- * - `mapForeignKeyRow()` - Map a foreign key query result row to ForeignKeySchema
- * - `mapTableNameRow()` - Extract table name from a row
- * - `mapPrimaryKeyRow()` - Extract column name from a PK row
- */
+/** A SQL introspector: an engine states its catalogue queries (`get*Query`) and how their rows map (`map*Result`). */
 export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector implements SchemaIntrospector {
     protected readonly pool: QuerierPool;
     constructor(pool: QuerierPool, schema?: string);
     /**
-     * The schema every catalogue query filters on, as SQL: the one that was asked for, or the engine's
-     * expression for the connection's default. A literal rather than a bind parameter because these
-     * queries are assembled as text and several use it more than once.
+     * The schema every catalogue query filters on, as SQL: the one that was asked for, as the engine's
+     * own literal, or its expression for the connection's default. A literal rather than a bind
+     * parameter because these queries are assembled as text and several use it more than once.
      */
     protected get schemaExpr(): string;
     /**
@@ -66,9 +48,7 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
     protected getIndexesParams(tableName: string): unknown[];
     protected getForeignKeysParams(tableName: string): unknown[];
     protected getPrimaryKeyParams(tableName: string): unknown[];
-    /**
-     * Normalize referential action string to standard type.
-     */
+    /** The {@link ForeignKeyAction} a catalogue names, whatever its case. */
     protected normalizeReferentialAction(action: string): ForeignKeyAction | undefined;
     /**
      * Convert bigint/null values to number safely.

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.js

@@ -1,25 +1,7 @@
+import { FOREIGN_KEY_ACTIONS } from '../../schema/types.js';
 import { isSqlQuerier } from '../../type/index.js';
-import { escapeAnsiSqlLiteral } from '../../util/sqlLiteral.js';
 import { BaseSqlIntrospector } from './baseSqlIntrospector.js';
-/**
- * Abstract base class for SQL schema introspectors.
- *
- * Uses the template-method pattern to consolidate shared logic while allowing
- * dialect-specific implementations for SQL queries and type normalization.
- *
- * Subclasses must implement:
- * - `getTableNamesQuery()` - SQL to list all table names
- * - `tableExistsQuery()` - SQL to check if a table exists
- * - `getColumnsQuery()` - SQL to get column metadata
- * - `getIndexesQuery()` - SQL to get index metadata
- * - `getForeignKeysQuery()` - SQL to get foreign key metadata
- * - `getPrimaryKeyQuery()` - SQL to get primary key columns
- * - `mapColumnRow()` - Map a column query result row to ColumnSchema
- * - `mapIndexRow()` - Map an index query result row to IndexSchema
- * - `mapForeignKeyRow()` - Map a foreign key query result row to ForeignKeySchema
- * - `mapTableNameRow()` - Extract table name from a row
- * - `mapPrimaryKeyRow()` - Extract column name from a PK row
- */
+/** A SQL introspector: an engine states its catalogue queries (`get*Query`) and how their rows map (`map*Result`). */
 export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     pool;
     constructor(pool, schema) {
@@ -27,12 +9,12 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
         this.pool = pool;
     }
     /**
-     * The schema every catalogue query filters on, as SQL: the one that was asked for, or the engine's
-     * expression for the connection's default. A literal rather than a bind parameter because these
-     * queries are assembled as text and several use it more than once.
+     * The schema every catalogue query filters on, as SQL: the one that was asked for, as the engine's
+     * own literal, or its expression for the connection's default. A literal rather than a bind
+     * parameter because these queries are assembled as text and several use it more than once.
      */
     get schemaExpr() {
-        return this.schema === undefined ? this.defaultSchemaExpr : escapeAnsiSqlLiteral(this.schema);
+        return this.schema === undefined ? this.defaultSchemaExpr : this.dialect.escape(this.schema);
     }
     /**
      * How this engine names the connection's current schema (Postgres) or database (MySQL). Empty on
@@ -118,24 +100,10 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     getPrimaryKeyParams(tableName) {
         return [tableName];
     }
-    /**
-     * Normalize referential action string to standard type.
-     */
+    /** The {@link ForeignKeyAction} a catalogue names, whatever its case. */
     normalizeReferentialAction(action) {
-        switch (action.toUpperCase()) {
-            case 'CASCADE':
-                return 'CASCADE';
-            case 'SET NULL':
-                return 'SET NULL';
-            case 'RESTRICT':
-                return 'RESTRICT';
-            case 'NO ACTION':
-                return 'NO ACTION';
-            case 'SET DEFAULT':
-                return 'SET DEFAULT';
-            default:
-                return undefined;
-        }
+        const upper = action.toUpperCase();
+        return FOREIGN_KEY_ACTIONS.find((known) => known === upper);
     }
     /**
      * Convert bigint/null values to number safely.

package/dist/migrate/introspection/baseSqlIntrospector.js

@@ -113,7 +113,6 @@ export class BaseSqlIntrospector {
                     type: idx.type,
                     where: idx.where,
                     include: idx.include,
-                    source: 'database',
                 };
                 ast.addIndex(index);
             }

package/dist/migrate/introspection/mongoIntrospector.d.ts

@@ -1,6 +1,6 @@
 import type { IndexFacet } from '../../schema/indexDifferences.js';
 import { SchemaAST } from '../../schema/schemaAST.js';
-import type { QuerierPool, SchemaIntrospector, TableSchema } from '../../type/index.js';
+import { type QuerierPool, type SchemaIntrospector, type TableSchema } from '../../type/index.js';
 /**
  * MongoDB schema introspector.
  * MongoDB doesn't have a fixed schema, so this primarily focuses on collections and indexes.
@@ -12,6 +12,8 @@ export declare class MongoSchemaIntrospector implements SchemaIntrospector {
     constructor(pool: QuerierPool);
     introspect(tables?: readonly string[]): Promise<SchemaAST>;
     getTableSchema(tableName: string): Promise<TableSchema | undefined>;
+    /** Collections only, the way a SQL engine lists its base tables: no view, nor the `system.views` behind one. */
     getTableNames(): Promise<string[]>;
     tableExists(tableName: string): Promise<boolean>;
+    private withDb;
 }

package/dist/migrate/introspection/mongoIntrospector.js

@@ -1,4 +1,5 @@
-import { SchemaAST } from '../../schema/schemaAST.js';
+import { createTableNode, SchemaAST } from '../../schema/schemaAST.js';
+import { isMongoQuerier, } from '../../type/index.js';
 /**
  * MongoDB schema introspector.
  * MongoDB doesn't have a fixed schema, so this primarily focuses on collections and indexes.
@@ -16,55 +17,22 @@ export class MongoSchemaIntrospector {
         for (const name of tableNames) {
             const schema = await this.getTableSchema(name);
             if (schema) {
-                const columns = new Map();
-                const table = {
-                    name,
-                    columns,
-                    primaryKey: [],
-                    indexes: [],
-                    incomingRelations: [],
-                    outgoingRelations: [],
-                };
-                if (schema.indexes) {
-                    for (const idx of schema.indexes) {
-                        for (const { column: colName } of idx.entries) {
-                            let column = columns.get(colName);
-                            if (!column) {
-                                column = {
-                                    name: colName,
-                                    type: { category: 'string' }, // MongoDB fields are flexible, but indexes usually target strings/numbers
-                                    nullable: true,
-                                    isPrimaryKey: false,
-                                    isAutoIncrement: false,
-                                    isUnique: false,
-                                    table,
-                                    referencedBy: [],
-                                };
-                                columns.set(colName, column);
-                            }
-                        }
-                        table.indexes.push({ name: idx.name, table, entries: idx.entries, unique: idx.unique });
-                    }
-                }
-                ast.addTable(table);
+                ast.addTable(buildTable(schema));
             }
         }
         return ast;
     }
     async getTableSchema(tableName) {
-        return this.pool.withQuerier(async (querier) => {
-            const { db } = querier;
-            const collections = await db.listCollections({ name: tableName }).toArray();
-            if (collections.length === 0) {
+        return this.withDb(async (db) => {
+            if (!(await hasCollection(db, tableName))) {
                 return undefined;
             }
-            // MongoDB doesn't have a fixed schema, but we can look at the indexes. Annotated rather than
-            // inferred: the driver's `indexes()` is overloaded and resolves to `any` on some versions, which
-            // silently made every field below unchecked.
+            // Annotated rather than inferred: the driver's `indexes()` is overloaded and resolves to `any` on
+            // some versions, which silently made every field below unchecked.
             const indexes = await db.collection(tableName).indexes();
             return {
                 name: tableName,
-                columns: [], // We don't have columns in Mongo
+                columns: [],
                 indexes: indexes.map((idx) => ({
                     name: idx.name ?? Object.keys(idx.key).join('_'),
                     entries: Object.keys(idx.key).map((column) => ({ column })),
@@ -73,15 +41,49 @@ export class MongoSchemaIntrospector {
             };
         });
     }
+    /** Collections only, the way a SQL engine lists its base tables: no view, nor the `system.views` behind one. */
     async getTableNames() {
-        return this.pool.withQuerier(async (querier) => {
-            const { db } = querier;
-            const collections = await db.listCollections().toArray();
-            return collections.map((c) => c.name);
+        return this.withDb(async (db) => {
+            const filter = { type: 'collection', name: { $not: /^system\./ } };
+            const collections = await db.listCollections(filter, { nameOnly: true }).toArray();
+            return collections.map((collection) => collection.name);
         });
     }
     async tableExists(tableName) {
-        const names = await this.getTableNames();
-        return names.includes(tableName);
+        return this.withDb((db) => hasCollection(db, tableName));
     }
+    withDb(task) {
+        return this.pool.withQuerier((querier) => {
+            if (!isMongoQuerier(querier)) {
+                throw new TypeError('MongoSchemaIntrospector requires a MongoDB querier');
+            }
+            return task(querier.db);
+        });
+    }
+}
+async function hasCollection(db, name) {
+    const collections = await db.listCollections({ name, type: 'collection' }, { nameOnly: true }).toArray();
+    return collections.length > 0;
+}
+/** Mongo has no columns to read, so a table's are the fields its indexes name, one node per field. */
+function buildTable({ name, indexes = [] }) {
+    const table = createTableNode(name);
+    for (const index of indexes) {
+        for (const { column } of index.entries) {
+            if (!table.columns.has(column)) {
+                table.columns.set(column, {
+                    name: column,
+                    type: { category: 'string' },
+                    nullable: true,
+                    isPrimaryKey: false,
+                    isAutoIncrement: false,
+                    isUnique: false,
+                    table,
+                    referencedBy: [],
+                });
+            }
+        }
+        table.indexes.push({ name: index.name, table, entries: index.entries, unique: index.unique });
+    }
+    return table;
 }

package/dist/migrate/introspection/mssqlIntrospector.d.ts

@@ -12,8 +12,8 @@ export declare class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospect
     protected readonly defaultSchemaExpr = "SCHEMA_NAME()";
     protected getTableNamesQuery(): string;
     protected tableExistsQuery(): string;
-    protected parseTableExistsResult(results: {
-        count?: number;
+    protected parseTableExistsResult([row]: {
+        count: number;
     }[]): boolean;
     /**
      * From `sys` rather than `INFORMATION_SCHEMA`, which has no identity flag and no per-column view of
@@ -40,8 +40,8 @@ export declare class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospect
         update_rule: string;
     }[]): Promise<ForeignKeySchema[]>;
     /**
-     * A default is stored wrapped in at least one layer of parentheses - `((0))` for a number,
-     * `(N'x')` for a string - because the engine reprints it from its own parse tree.
+     * The engine reprints a default from its own parse tree: all of it in one pair of parentheses, and a
+     * number in a second, so `((0))`, `((1)+(2))`, `(N'x')` and `(getdate())`.
      */
     protected parseDefaultValue(defaultValue: string | null): unknown;
 }

package/dist/migrate/introspection/mssqlIntrospector.js

@@ -26,9 +26,8 @@ export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         AND TABLE_NAME = @p1
     `;
     }
-    parseTableExistsResult(results) {
-        // No row, or no count in it, reads as `NaN`, which is not above zero.
-        return Number(results[0]?.count) > 0;
+    parseTableExistsResult([row]) {
+        return row.count > 0;
     }
     /**
      * From `sys` rather than `INFORMATION_SCHEMA`, which has no identity flag and no per-column view of
@@ -142,46 +141,38 @@ export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     async mapIndexesResult(_read, _tableName, results) {
         return results.map((row) => ({
             name: row.index_name,
-            entries: (row.columns ?? '').split(',').map((column) => ({ column })),
+            entries: row.columns.split(',').map((column) => ({ column })),
             unique: Boolean(row.is_unique),
         }));
     }
     async mapForeignKeysResult(_read, _tableName, results) {
         return results.map((row) => ({
             name: row.constraint_name,
-            columns: (row.columns || '').split(','),
-            references: { table: row.referenced_table, columns: (row.referenced_columns || '').split(',') },
+            columns: row.columns.split(','),
+            references: { table: row.referenced_table, columns: row.referenced_columns.split(',') },
             // `sys` spells them with an underscore: `SET_NULL`, `NO_ACTION`.
-            onDelete: this.normalizeReferentialAction((row.delete_rule || '').replaceAll('_', ' ')),
-            onUpdate: this.normalizeReferentialAction((row.update_rule || '').replaceAll('_', ' ')),
+            onDelete: this.normalizeReferentialAction(row.delete_rule.replaceAll('_', ' ')),
+            onUpdate: this.normalizeReferentialAction(row.update_rule.replaceAll('_', ' ')),
         }));
     }
     /**
-     * A default is stored wrapped in at least one layer of parentheses - `((0))` for a number,
-     * `(N'x')` for a string - because the engine reprints it from its own parse tree.
+     * The engine reprints a default from its own parse tree: all of it in one pair of parentheses, and a
+     * number in a second, so `((0))`, `((1)+(2))`, `(N'x')` and `(getdate())`.
      */
     parseDefaultValue(defaultValue) {
-        if (defaultValue === null || defaultValue === undefined) {
+        if (defaultValue === null) {
             return undefined;
         }
-        let text = defaultValue.trim();
-        while (text.startsWith('(') && text.endsWith(')')) {
-            text = text.slice(1, -1).trim();
+        const text = defaultValue.slice(1, -1);
+        const number = /^\((-?\d+(?:\.\d+)?)\)$/.exec(text);
+        if (number) {
+            return Number(number[1]);
         }
-        if (text.toUpperCase() === 'NULL') {
-            return null;
+        const quoted = /^N?'(.*)'$/s.exec(text);
+        if (quoted) {
+            return quoted[1].replaceAll("''", "'");
         }
-        const unicode = text.startsWith("N'") ? text.slice(1) : text;
-        if (unicode.startsWith("'") && unicode.endsWith("'")) {
-            return unicode.slice(1, -1).replaceAll("''", "'");
-        }
-        if (/^-?\d+$/.test(text)) {
-            return Number.parseInt(text, 10);
-        }
-        if (/^-?\d+\.\d+$/.test(text)) {
-            return Number.parseFloat(text);
-        }
-        return text;
+        return text === 'NULL' ? null : text;
     }
 }
 /** The types whose `max_length` is a width rather than a fixed storage size. */

package/dist/migrate/introspection/mysqlIntrospector.d.ts

@@ -8,8 +8,8 @@ export declare class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospect
     protected readonly defaultSchemaExpr = "DATABASE()";
     protected getTableNamesQuery(): string;
     protected tableExistsQuery(): string;
-    protected parseTableExistsResult(results: {
-        count?: number | bigint;
+    protected parseTableExistsResult([row]: {
+        count: number | bigint;
     }[]): boolean;
     protected getColumnsQuery(_tableName: string): string;
     protected getIndexesQuery(_tableName: string): string;
@@ -29,6 +29,11 @@ export declare class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospect
         delete_rule: string;
         update_rule: string;
     }[]): Promise<ForeignKeySchema[]>;
+    /**
+     * MariaDB prints a string default as the literal it is (`'it''s'`). MySQL prints one bare, save an
+     * expression default (`DEFAULT ('x')`, what a `TEXT` column takes), which comes with a charset
+     * introducer and every quote and backslash escaped once more: `_utf8mb4\'x\'`.
+     */
     protected parseDefaultValue(defaultValue: string | null): unknown;
 }
 type MysqlColumnRow = {