uql-orm 0.65.1 → 0.67.0

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 = {

package/dist/migrate/introspection/mysqlIntrospector.js

@@ -1,3 +1,4 @@
+import { unescapeMysqlString } from '../../util/sqlLiteral.js';
 import { AbstractSqlSchemaIntrospector } from './abstractSqlSchemaIntrospector.js';
 /**
  * MySQL/MariaDB schema introspector.
@@ -23,9 +24,8 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         AND TABLE_NAME = ?
     `;
     }
-    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 Number(row.count) > 0;
     }
     getColumnsQuery(_tableName) {
         return /*sql*/ `
@@ -98,7 +98,7 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             nullable: row.is_nullable === 'YES',
             defaultValue: this.parseDefaultValue(row.column_default),
             isPrimaryKey: row.column_key === 'PRI',
-            isAutoIncrement: (row.extra || '').toLowerCase().includes('auto_increment'),
+            isAutoIncrement: row.extra.toLowerCase().includes('auto_increment'),
             isUnique: row.column_key === 'UNI',
             length: this.toNumber(row.character_maximum_length),
             precision: this.toNumber(row.numeric_precision),
@@ -112,7 +112,7 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             // A functional or multi-valued key part has no `COLUMN_NAME` - the `COALESCE` above keeps its
             // place in the list, and it is reported as the expression it is, which is what stops diffing
             // from comparing an entry list the server cannot state against the entity's own.
-            entries: (row.columns ?? '').split(',').map((column) => (column ? { column } : { column, expression: true })),
+            entries: row.columns.split(',').map((column) => (column ? { column } : { column, expression: true })),
             unique: Boolean(row.is_unique),
         }));
     }
@@ -125,6 +125,11 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             onUpdate: this.normalizeReferentialAction(row.update_rule),
         }));
     }
+    /**
+     * 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\'`.
+     */
     parseDefaultValue(defaultValue) {
         if (defaultValue === null) {
             return undefined;
@@ -136,16 +141,13 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         if (normalized === 'CURRENT_TIMESTAMP' || normalized === 'CURRENT_TIMESTAMP()') {
             return 'CURRENT_TIMESTAMP';
         }
-        if (/^-?\d+$/.test(defaultValue)) {
-            return Number.parseInt(defaultValue, 10);
+        if (/^-?\d+(\.\d+)?$/.test(defaultValue)) {
+            return Number(defaultValue);
         }
-        if (/^-?\d+\.\d+$/.test(defaultValue)) {
-            return Number.parseFloat(defaultValue);
-        }
-        if (defaultValue?.startsWith("'") && defaultValue?.endsWith("'")) {
-            return defaultValue.slice(1, -1);
-        }
-        return defaultValue;
+        const introduced = /^_\w+(\\'.*\\')$/s.exec(defaultValue);
+        const literal = introduced ? unescapeMysqlString(introduced[1]) : defaultValue;
+        const quoted = /^'(.*)'$/s.exec(literal);
+        return quoted ? unescapeMysqlString(quoted[1]) : literal;
     }
 }
 /**

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

@@ -13,7 +13,7 @@ export declare class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrosp
     readonly indexFacets: ReadonlySet<IndexFacet>;
     protected getTableNamesQuery(): string;
     protected tableExistsQuery(): string;
-    protected parseTableExistsResult(results: RawRow[]): boolean;
+    protected parseTableExistsResult([row]: RawRow[]): boolean;
     protected getColumnsQuery(_tableName: string): string;
     /**
      * `attname` where the entry is a column, `pg_get_indexdef` for that one position where it is an
@@ -36,22 +36,29 @@ export declare class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrosp
      * compare. This one decides which indexes are reported at all.
      */
     protected readonly constraintIndexTypes: readonly string[];
+    /** From `pg_constraint`, whose key arrays keep each column paired with the one it references. */
     protected getForeignKeysQuery(_tableName: string): string;
     protected getPrimaryKeyQuery(_tableName: string): string;
     protected mapColumnsResult(_read: TableRowReader, _tableName: string, results: PostgresColumnRow[]): Promise<ColumnSchema[]>;
     protected mapIndexesResult(_read: TableRowReader, _tableName: string, results: PostgresIndexRow[]): Promise<IndexSchema[]>;
-    protected mapForeignKeysResult(_read: TableRowReader, _tableName: string, results: {
-        constraint_name: string;
-        columns: string[];
-        referenced_table: string;
-        referenced_columns: string[];
-        delete_rule: string;
-        update_rule: string;
-    }[]): Promise<ForeignKeySchema[]>;
+    protected mapForeignKeysResult(_read: TableRowReader, _tableName: string, results: PostgresForeignKeyRow[]): Promise<ForeignKeySchema[]>;
     protected normalizeType(dataType: string, udtName: string): string;
+    /**
+     * Postgres quotes a negative number (`'-3'::integer`); CockroachDB parenthesizes one (`(-3)`) and
+     * writes a quote-bearing string in escape syntax (`e'it\'s'`). Any other cast is dropped, and a
+     * function call (`now()`, `nextval(...)`) is returned as written.
+     */
     protected parseDefaultValue(defaultValue: string | null): unknown;
     protected isAutoIncrement(columnDefault: string | null, isIdentity: string): boolean;
 }
+/** `pg_constraint`'s one-letter spelling of each action. */
+declare const FOREIGN_KEY_ACTION_CODES: {
+    readonly a: 'NO ACTION';
+    readonly r: 'RESTRICT';
+    readonly c: 'CASCADE';
+    readonly n: 'SET NULL';
+    readonly d: 'SET DEFAULT';
+};
 /**
  * CockroachDB answers the same catalogue queries and differs only in what it can express: v26.2.5
  * still rejects `NULLS FIRST/LAST` and operator classes as "unimplemented", and it sorts nulls first
@@ -69,6 +76,14 @@ export declare class CockroachSchemaIntrospector extends PostgresSchemaIntrospec
      */
     protected readonly constraintIndexTypes: readonly string[];
 }
+type PostgresForeignKeyRow = {
+    constraint_name: string;
+    columns: string[];
+    referenced_table: string;
+    referenced_columns: string[];
+    delete_rule: keyof typeof FOREIGN_KEY_ACTION_CODES;
+    update_rule: keyof typeof FOREIGN_KEY_ACTION_CODES;
+};
 /** One entry of one index; what the index itself is repeats across its rows. */
 type PostgresIndexRow = {
     index_name: string;

package/dist/migrate/introspection/postgresIntrospector.js

@@ -34,8 +34,8 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
       ) AS exists
     `;
     }
-    parseTableExistsResult(results) {
-        return results[0]?.['exists'] ?? false;
+    parseTableExistsResult([row]) {
+        return row['exists'] === true;
     }
     getColumnsQuery(_tableName) {
         return /*sql*/ `
@@ -50,28 +50,25 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         c.numeric_scale,
         c.is_identity,
         c.identity_generation,
-        COALESCE(
-          (SELECT TRUE FROM information_schema.table_constraints tc
-           JOIN information_schema.key_column_usage kcu
-             ON tc.constraint_name = kcu.constraint_name
-           WHERE tc.table_name = c.table_name
-             AND tc.constraint_type = 'PRIMARY KEY'
-             AND kcu.column_name = c.column_name
-           LIMIT 1),
-          FALSE
+        EXISTS (
+          SELECT 1 FROM information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu USING (constraint_schema, constraint_name)
+          WHERE tc.table_schema = c.table_schema
+            AND tc.table_name = c.table_name
+            AND tc.constraint_type = 'PRIMARY KEY'
+            AND kcu.column_name = c.column_name
         ) AS is_primary_key,
-        COALESCE(
-          (SELECT TRUE FROM information_schema.table_constraints tc
-           JOIN information_schema.key_column_usage kcu
-             ON tc.constraint_name = kcu.constraint_name
-           WHERE tc.table_name = c.table_name
-             AND tc.constraint_type = 'UNIQUE'
-             AND kcu.column_name = c.column_name
-           LIMIT 1),
-          FALSE
+        EXISTS (
+          SELECT 1 FROM information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu USING (constraint_schema, constraint_name)
+          WHERE tc.table_schema = c.table_schema
+            AND tc.table_name = c.table_name
+            AND tc.constraint_type = 'UNIQUE'
+          GROUP BY tc.constraint_name
+          HAVING COUNT(*) = 1 AND MIN(kcu.column_name) = c.column_name
         ) AS is_unique,
         pg_catalog.col_description(
-          (SELECT oid FROM pg_catalog.pg_class WHERE relname = c.table_name),
+          (quote_ident(c.table_schema) || '.' || quote_ident(c.table_name))::regclass,
           c.ordinal_position
         ) AS column_comment
       FROM information_schema.columns c
@@ -113,7 +110,7 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
       LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum AND k.attnum > 0
       LEFT JOIN pg_opclass op ON op.oid = ix.indclass[k.n - 1]
       WHERE t.relname = $1
-        AND n.nspname = 'public'
+        AND n.nspname = ${this.schemaExpr}
         AND NOT ix.indisprimary
         AND NOT EXISTS (
           SELECT 1 FROM pg_constraint con
@@ -132,30 +129,29 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
      * compare. This one decides which indexes are reported at all.
      */
     constraintIndexTypes = ['p', 'u', 'x'];
+    /** From `pg_constraint`, whose key arrays keep each column paired with the one it references. */
     getForeignKeysQuery(_tableName) {
+        const columnsOf = (keys, table) => /*sql*/ `ARRAY_TO_JSON(ARRAY(
+      SELECT a.attname FROM UNNEST(${keys}) WITH ORDINALITY AS k(attnum, n)
+      JOIN pg_attribute a ON a.attrelid = ${table} AND a.attnum = k.attnum
+      ORDER BY k.n
+    ))`;
         return /*sql*/ `
       SELECT
-        tc.constraint_name,
-        ARRAY_TO_JSON(ARRAY_AGG(kcu.column_name ORDER BY kcu.ordinal_position)) AS columns,
-        ccu.table_name AS referenced_table,
-        ARRAY_TO_JSON(ARRAY_AGG(ccu.column_name ORDER BY kcu.ordinal_position)) AS referenced_columns,
-        rc.delete_rule,
-        rc.update_rule
-      FROM information_schema.table_constraints tc
-      JOIN information_schema.key_column_usage kcu
-        ON tc.constraint_name = kcu.constraint_name
-        AND tc.table_schema = kcu.table_schema
-      JOIN information_schema.constraint_column_usage ccu
-        ON ccu.constraint_name = tc.constraint_name
-        AND ccu.table_schema = tc.table_schema
-      JOIN information_schema.referential_constraints rc
-        ON rc.constraint_name = tc.constraint_name
-        AND rc.constraint_schema = tc.table_schema
-      WHERE tc.constraint_type = 'FOREIGN KEY'
-        AND tc.table_name = $1
-        AND tc.table_schema = ${this.schemaExpr}
-      GROUP BY tc.constraint_name, ccu.table_name, rc.delete_rule, rc.update_rule
-      ORDER BY tc.constraint_name
+        con.conname AS constraint_name,
+        ${columnsOf('con.conkey', 'con.conrelid')} AS columns,
+        ref.relname AS referenced_table,
+        ${columnsOf('con.confkey', 'con.confrelid')} AS referenced_columns,
+        con.confdeltype AS delete_rule,
+        con.confupdtype AS update_rule
+      FROM pg_constraint con
+      JOIN pg_class t ON t.oid = con.conrelid
+      JOIN pg_namespace n ON n.oid = t.relnamespace
+      JOIN pg_class ref ON ref.oid = con.confrelid
+      WHERE con.contype = 'f'
+        AND t.relname = $1
+        AND n.nspname = ${this.schemaExpr}
+      ORDER BY con.conname
     `;
     }
     getPrimaryKeyQuery(_tableName) {
@@ -205,8 +201,8 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             name: row.constraint_name,
             columns: row.columns,
             references: { table: row.referenced_table, columns: row.referenced_columns },
-            onDelete: this.normalizeReferentialAction(row.delete_rule),
-            onUpdate: this.normalizeReferentialAction(row.update_rule),
+            onDelete: FOREIGN_KEY_ACTION_CODES[row.delete_rule],
+            onUpdate: FOREIGN_KEY_ACTION_CODES[row.update_rule],
         }));
     }
     normalizeType(dataType, udtName) {
@@ -219,29 +215,32 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         }
         return dataType.toUpperCase();
     }
+    /**
+     * Postgres quotes a negative number (`'-3'::integer`); CockroachDB parenthesizes one (`(-3)`) and
+     * writes a quote-bearing string in escape syntax (`e'it\'s'`). Any other cast is dropped, and a
+     * function call (`now()`, `nextval(...)`) is returned as written.
+     */
     parseDefaultValue(defaultValue) {
         if (!defaultValue) {
             return undefined;
         }
-        // Remove type casting (e.g., ::text, ::character varying, ::text[])
         const cleaned = defaultValue.replace(/::[a-z_]+(\s+[a-z_]+)?(\[\])?/gi, '').trim();
-        if (cleaned.startsWith("'") && cleaned.endsWith("'")) {
-            return cleaned.slice(1, -1);
+        const number = NUMBER_DEFAULT.exec(cleaned) ?? QUOTED_NUMBER_DEFAULT.exec(defaultValue);
+        if (number) {
+            return Number(number[1]);
         }
-        if (cleaned === 'true' || cleaned === 'false') {
-            return cleaned === 'true';
+        const quoted = /^'(.*)'$/s.exec(cleaned);
+        if (quoted) {
+            return quoted[1].replaceAll("''", "'");
         }
-        if (cleaned === 'NULL') {
-            return null;
+        const escaped = /^e'(.*)'$/s.exec(cleaned);
+        if (escaped) {
+            return escaped[1].replace(/\\(.)/gs, '$1');
         }
-        if (/^-?\d+$/.test(cleaned)) {
-            return Number.parseInt(cleaned, 10);
-        }
-        if (/^-?\d+\.\d+$/.test(cleaned)) {
-            return Number.parseFloat(cleaned);
+        if (cleaned === 'true' || cleaned === 'false') {
+            return cleaned === 'true';
         }
-        // Return cleaned value for functions like CURRENT_TIMESTAMP, nextval(), etc.
-        return cleaned;
+        return cleaned === 'NULL' ? null : cleaned;
     }
     isAutoIncrement(columnDefault, isIdentity) {
         // PostgreSQL identity columns (GENERATED ... AS IDENTITY)
@@ -252,6 +251,16 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         return columnDefault?.includes('nextval(') ?? false;
     }
 }
+/** `pg_constraint`'s one-letter spelling of each action. */
+const FOREIGN_KEY_ACTION_CODES = {
+    a: 'NO ACTION',
+    r: 'RESTRICT',
+    c: 'CASCADE',
+    n: 'SET NULL',
+    d: 'SET DEFAULT',
+};
+const NUMBER_DEFAULT = /^\(?(-?\d+(?:\.\d+)?)\)?$/;
+const QUOTED_NUMBER_DEFAULT = /^'(-?\d+(?:\.\d+)?)'::(?:smallint|integer|bigint|numeric|real|double precision)$/;
 /**
  * Postgres states every entry in full: a plain column still reports `order: 'asc'`, and only a
  * non-default operator class is named. The diff defaults the entity side to match, so an option

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

@@ -6,7 +6,7 @@ import { AbstractSqlSchemaIntrospector, type TableRowReader } from './abstractSq
 export declare class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     protected getTableNamesQuery(): string;
     protected tableExistsQuery(): string;
-    protected parseTableExistsResult(results: SqliteCountRow[]): boolean;
+    protected parseTableExistsResult([row]: SqliteCountRow[]): boolean;
     /**
      * `table_xinfo`, not `table_info`: the latter omits generated columns entirely, so a table carrying
      * one read back without it and every sync offered to add a column that was already there - which

package/dist/migrate/introspection/sqliteIntrospector.js

@@ -21,9 +21,8 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         AND name = ?
     `;
     }
-    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 Number(row.count) > 0;
     }
     /**
      * `table_xinfo`, not `table_info`: the latter omits generated columns entirely, so a table carrying
@@ -59,15 +58,16 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         return row.name;
     }
     async mapColumnsResult(read, tableName, results) {
-        // Get unique columns from indexes
         const uniqueColumns = await this.getUniqueColumns(read, tableName);
+        // Only a sole `INTEGER PRIMARY KEY` is the rowid, which is what numbers itself.
+        const soleKey = results.filter((row) => row.pk > 0).length === 1;
         return results.map((row) => ({
             name: row.name,
             type: this.normalizeType(row.type),
             nullable: row.notnull === 0,
             defaultValue: this.parseDefaultValue(row.dflt_value),
             isPrimaryKey: row.pk > 0,
-            isAutoIncrement: row.pk > 0 && row.type.toUpperCase() === 'INTEGER',
+            isAutoIncrement: soleKey && row.pk > 0 && row.type.toUpperCase() === 'INTEGER',
             isUnique: uniqueColumns.has(row.name),
             length: this.extractLength(row.type),
             precision: undefined,
@@ -130,8 +130,9 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     async getUniqueColumns(read, tableName) {
         const indexes = await read(this.getIndexesQuery(tableName));
         const uniqueColumns = new Set();
+        // The key's own index is left out: a key column is unique already, which the entity side never states.
         for (const index of indexes) {
-            if (index.unique) {
+            if (index.unique && index.origin !== 'pk') {
                 const columns = await this.getIndexColumns(read, index.name);
                 // Only single-column unique constraints, and only over a real column (not an expression)
                 const [column] = columns;
@@ -165,14 +166,11 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             return defaultValue;
         }
         if (/^'.*'$/.test(defaultValue)) {
-            return defaultValue.slice(1, -1);
+            return defaultValue.slice(1, -1).replaceAll("''", "'");
         }
         if (/^-?\d+$/.test(defaultValue)) {
             return Number.parseInt(defaultValue, 10);
         }
-        if (typeof defaultValue !== 'string') {
-            return defaultValue;
-        }
         if (/^-?\d+\.\d+$/.test(defaultValue)) {
             return Number.parseFloat(defaultValue);
         }