uql-orm 0.51.0 → 0.53.0

package/dist/dialect/mergeSqlDialect.d.ts

@@ -0,0 +1,45 @@
+import type { QueryConflictPaths, QueryContext, QueryPager, Type } from '../type/index.js';
+import { AbstractSqlDialect } from './abstractSqlDialect.js';
+/**
+ * Shared SQL between SQL Server and Oracle: the two engines that spell paging and upsert the way the
+ * standard does, where the Postgres and MySQL families each predate it.
+ *
+ * A family base rather than a pair of knobs, the way {@link PgLikeSqlDialect} and
+ * {@link MysqlLikeSqlDialect} already are - `pager` and `upsert` are both plain overrides, so nothing
+ * in the core has to learn that a second spelling exists.
+ */
+export declare abstract class MergeSqlDialect extends AbstractSqlDialect {
+    readonly escapeIdChar = "\"";
+    /**
+     * `OFFSET ... ROWS FETCH NEXT ... ROWS ONLY`, and an `ORDER BY` where the statement has none.
+     *
+     * SQL Server refuses to page an unordered statement. A constant `ORDER BY` costs one clause the
+     * optimizer discards and keeps `$limit` and `$skip` meaning the same thing here as everywhere
+     * else; the alternative, `TOP (n)` in the select list, needs a second hook and still leaves a
+     * `$skip` with no `$sort` unanswerable.
+     */
+    pager(ctx: QueryContext, opts: QueryPager & {
+        $distinct?: boolean;
+    }, sorted?: boolean): void;
+    /**
+     * `MERGE`, which both engines take in place of the `ON CONFLICT`/`ON DUPLICATE KEY` the other
+     * families have. The rows go in as a `VALUES` row source rather than an `INSERT`, built by
+     * {@link AbstractSqlDialect.insertShape} so both shapes apply `onInsert` defaults identically.
+     *
+     * Every value binds before the assignments are rendered, so a `?`-placeholder engine needs none of
+     * the scratch-context reordering `ON CONFLICT` does - the source is read positionally, in order.
+     */
+    upsert<E>(ctx: QueryContext, entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E | E[], extraReturning?: string): void;
+    /** `<target>.<col> = <source>.<col>` for every conflict key, which is what makes a row "the same". */
+    private mergeOn;
+    /**
+     * A lock hint on the merge target. `MERGE` takes an update key lock but releases it before the
+     * insert, so two concurrent upserts of the same key race into a duplicate-key error; `HOLDLOCK`
+     * holds it across both. Empty on Oracle, which does not have the hint and does not need it.
+     */
+    protected readonly mergeTargetHint: string;
+    /** How the merge reports the row it wrote. Oracle has no such clause on a `MERGE` and omits it. */
+    protected mergeReturning(expression: string): string;
+    /** `MERGE` must be terminated on SQL Server; nothing else here cares. */
+    protected readonly statementTerminator: string;
+}

package/dist/dialect/mergeSqlDialect.js

@@ -0,0 +1,89 @@
+import { getMeta } from '../entity/index.js';
+import { assertNonNegativeInteger, getKeys } from '../util/index.js';
+import { AbstractSqlDialect } from './abstractSqlDialect.js';
+import { UPSERT_SOURCE_ALIAS } from './aliases.js';
+/**
+ * Shared SQL between SQL Server and Oracle: the two engines that spell paging and upsert the way the
+ * standard does, where the Postgres and MySQL families each predate it.
+ *
+ * A family base rather than a pair of knobs, the way {@link PgLikeSqlDialect} and
+ * {@link MysqlLikeSqlDialect} already are - `pager` and `upsert` are both plain overrides, so nothing
+ * in the core has to learn that a second spelling exists.
+ */
+export class MergeSqlDialect extends AbstractSqlDialect {
+    escapeIdChar = '"';
+    /**
+     * `OFFSET ... ROWS FETCH NEXT ... ROWS ONLY`, and an `ORDER BY` where the statement has none.
+     *
+     * SQL Server refuses to page an unordered statement. A constant `ORDER BY` costs one clause the
+     * optimizer discards and keeps `$limit` and `$skip` meaning the same thing here as everywhere
+     * else; the alternative, `TOP (n)` in the select list, needs a second hook and still leaves a
+     * `$skip` with no `$sort` unanswerable.
+     */
+    pager(ctx, opts, sorted = false) {
+        if (opts.$limit === undefined && opts.$skip === undefined) {
+            return;
+        }
+        if (!sorted) {
+            // A `SELECT DISTINCT` may only order by something it projects, so the constant cannot be used
+            // there; the first projected column is the one term always available.
+            ctx.append(` ORDER BY ${opts.$distinct ? '1' : '(SELECT NULL)'}`);
+        }
+        ctx.append(` OFFSET ${assertNonNegativeInteger(opts.$skip ?? 0, '$skip')} ROWS`);
+        if (opts.$limit !== undefined) {
+            ctx.append(` FETCH NEXT ${assertNonNegativeInteger(opts.$limit, '$limit')} ROWS ONLY`);
+        }
+    }
+    /**
+     * `MERGE`, which both engines take in place of the `ON CONFLICT`/`ON DUPLICATE KEY` the other
+     * families have. The rows go in as a `VALUES` row source rather than an `INSERT`, built by
+     * {@link AbstractSqlDialect.insertShape} so both shapes apply `onInsert` defaults identically.
+     *
+     * Every value binds before the assignments are rendered, so a `?`-placeholder engine needs none of
+     * the scratch-context reordering `ON CONFLICT` does - the source is read positionally, in order.
+     */
+    upsert(ctx, entity, conflictPaths, payload, extraReturning = '') {
+        const meta = getMeta(entity);
+        const table = this.escapedTableName(meta);
+        const source = this.escapeId(UPSERT_SOURCE_ALIAS, true);
+        // Before the row source, which is what fills the payload's `onInsert` fields: a column that
+        // exists only there - the generated key, `createdAt` - must not join the update set, or a row
+        // that already existed has both rewritten.
+        const update = this.getUpsertUpdateAssignments(ctx, meta, conflictPaths, payload, (col) => `${source}.${col}`);
+        const shape = this.insertShape(entity, payload);
+        const columns = shape.columns.join(', ');
+        ctx.append(`MERGE INTO ${table}${this.mergeTargetHint} USING (VALUES `);
+        this.appendValueRows(ctx, shape);
+        ctx.append(`) AS ${source} (${columns}) ON ${this.mergeOn(meta, conflictPaths, table, source)}`);
+        if (update) {
+            ctx.append(` WHEN MATCHED THEN UPDATE SET ${update}`);
+        }
+        ctx.append(` WHEN NOT MATCHED THEN INSERT (${columns}) VALUES (${shape.columns.map((col) => `${source}.${col}`).join(', ')})`);
+        const returning = [this.returningIdExpression(meta), extraReturning].filter(Boolean).join(', ');
+        if (returning) {
+            ctx.append(` ${this.mergeReturning(returning)}`);
+        }
+        ctx.append(this.statementTerminator);
+    }
+    /** `<target>.<col> = <source>.<col>` for every conflict key, which is what makes a row "the same". */
+    mergeOn(meta, conflictPaths, table, source) {
+        return getKeys(conflictPaths)
+            .map((key) => {
+            const column = this.escapeId(this.resolveColumnName(key, meta.fields[key]));
+            return `${table}.${column} = ${source}.${column}`;
+        })
+            .join(' AND ');
+    }
+    /**
+     * A lock hint on the merge target. `MERGE` takes an update key lock but releases it before the
+     * insert, so two concurrent upserts of the same key race into a duplicate-key error; `HOLDLOCK`
+     * holds it across both. Empty on Oracle, which does not have the hint and does not need it.
+     */
+    mergeTargetHint = '';
+    /** How the merge reports the row it wrote. Oracle has no such clause on a `MERGE` and omits it. */
+    mergeReturning(expression) {
+        return `RETURNING ${expression}`;
+    }
+    /** `MERGE` must be terminated on SQL Server; nothing else here cares. */
+    statementTerminator = '';
+}

package/dist/dialect/mysqlLikeSqlDialect.d.ts

@@ -41,7 +41,6 @@ export declare abstract class MysqlLikeSqlDialect extends AbstractSqlDialect {
     readonly dropForeignKeySyntax = "DROP FOREIGN KEY";
     readonly dropPrimaryKeySyntax = "DROP PRIMARY KEY";
     readonly dropIndexSyntax = "on-table";
-    readonly renameTableSyntax = "rename-table";
     readonly alterColumnSyntax = "MODIFY COLUMN";
     readonly booleanLiteral = "integer";
     readonly insertIdSource: InsertIdSource;

package/dist/dialect/mysqlLikeSqlDialect.js

@@ -29,7 +29,6 @@ export class MysqlLikeSqlDialect extends AbstractSqlDialect {
         indexIfNotExists: false,
         schemas: true,
         dropTableCascade: false,
-        renameColumn: true,
         foreignKeyAlter: true,
         primaryKeyAlter: true,
         generatedColumnAdd: true,
@@ -37,7 +36,9 @@ export class MysqlLikeSqlDialect extends AbstractSqlDialect {
         vectorIndexRequiresNotNull: false,
         vectorSupportsLength: false,
         supportsTimestamptz: false,
-        defaultStringAsText: false,
+        stringSizing: 'varchar',
+        supportsUnsigned: true,
+        serverSideCursors: false,
     };
     /**
      * `information_schema` keeps InnoDB's own row estimate, which is live enough to answer before
@@ -81,7 +82,6 @@ export class MysqlLikeSqlDialect extends AbstractSqlDialect {
     dropForeignKeySyntax = 'DROP FOREIGN KEY';
     dropPrimaryKeySyntax = 'DROP PRIMARY KEY';
     dropIndexSyntax = 'on-table';
-    renameTableSyntax = 'rename-table';
     alterColumnSyntax = 'MODIFY COLUMN';
     booleanLiteral = 'integer';
     // No `RETURNING` support, so multi-row insert IDs are inferred from the header - see the

package/dist/dialect/pgLikeSqlDialect.js

@@ -29,7 +29,6 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
         indexIfNotExists: true,
         schemas: true,
         dropTableCascade: true,
-        renameColumn: true,
         foreignKeyAlter: true,
         primaryKeyAlter: true,
         generatedColumnAdd: true,
@@ -37,7 +36,9 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
         vectorIndexRequiresNotNull: false,
         vectorSupportsLength: true,
         supportsTimestamptz: true,
-        defaultStringAsText: true,
+        stringSizing: 'bounded-text',
+        supportsUnsigned: false,
+        serverSideCursors: true,
     };
     escapeIdChar = '"';
     // Shared default for both dialects. CockroachDB docs flag sequential PKs as a hotspotting risk

package/dist/dialect/vectorSqlDialect.js

@@ -124,7 +124,8 @@ export class VectorSqlDialect extends AbstractDialect {
             throw unsupportedVectorMetric(this.dialectName, distance);
         }
         if ('fn' in metric) {
-            ctx.append(`${metric.fn}(${this.escapeId(colName)}, `);
+            const leading = metric.metricArg === undefined ? '' : `'${metric.metricArg}', `;
+            ctx.append(`${metric.fn}(${leading}${this.escapeId(colName)}, `);
             this.appendVectorValue(ctx, search.$vector, field);
             ctx.append(')');
             return;

package/dist/http/handler.js

@@ -1,5 +1,6 @@
 import { withContext } from '../context/context.js';
 import { getEntities, getMeta, soleIdOf } from '../entity/index.js';
+import { whereIds } from '../util/dialect.util.js';
 import { entityPath, matchRoute } from './contract.js';
 import { parseQueryParams } from './query.js';
 /** `Company (crm.Company)`: the class, and the table it maps, which is what tells two apart. */
@@ -145,7 +146,7 @@ export function createRequestHandler(opts) {
                         if (founds.length) {
                             const idKey = soleIdOf(meta, 'the HTTP handler');
                             ids = founds.map((found) => found[idKey]);
-                            count = await querier.deleteMany(entity, { $where: ids }, { hardDelete });
+                            count = await querier.deleteMany(entity, { $where: whereIds(meta, ids) }, { hardDelete });
                         }
                         return ok({ data: ids, count });
                     });
@@ -157,16 +158,6 @@ function ok(body) {
     return { status: 200, body };
 }
 function buildIdQuery(meta, id, query) {
-    const idKey = soleIdOf(meta, 'the HTTP handler');
-    const where = query.$where;
-    if (Array.isArray(where)) {
-        query.$where = { $and: [{ [idKey]: { $in: where } }, { [idKey]: id }] };
-    }
-    else if (typeof where === 'object' && where !== null) {
-        query.$where = { ...where, [idKey]: id };
-    }
-    else {
-        query.$where = { [idKey]: id };
-    }
+    query.$where = { ...query.$where, [soleIdOf(meta, 'the HTTP handler')]: id };
     return query;
 }

package/dist/http/query.js

@@ -1,7 +1,7 @@
 // the clause lists themselves, not the barrel: this module is in the browser bundle's graph
 import { QUERY_BOOLEAN_CLAUSES, QUERY_NUMBER_CLAUSES, QUERY_OBJECT_CLAUSES, QUERY_ROOT_NUMBER_CLAUSES, QUERY_ROOT_OBJECT_CLAUSES, } from '../type/query.js';
 // the specific util module, not the barrel, so the browser bundle does not pull in entity metadata
-import { getKeys } from '../util/object.util.js';
+import { getKeys, isWhereMap } from '../util/object.util.js';
 /**
  * Keys accepted from the wire - query structure ({@link Query}) plus the `hardDelete`/`count` scalar
  * flags. Anything else (e.g. `filters`, `context`, `$entity`) is dropped so a remote client can't
@@ -50,6 +50,9 @@ export function parseQueryParams(params = {}) {
         }
     }
     query['$where'] ??= {};
+    if (!isWhereMap(query['$where'])) {
+        throw Object.assign(new TypeError("'$where' must be a JSON object"), { status: 400 });
+    }
     // A query string carries every value as text, so what decodes a clause is the shape its group
     // declares. `'false'` is the reason the boolean pass exists rather than the raw value being taken:
     // it is a non-empty string, so a `$distinct=false` would otherwise read as asking for one.

package/dist/migrate/builder/expressions.js

@@ -26,6 +26,11 @@ export const DIALECT_DEFAULTS = {
     mysql: { expressions: MYSQL, wrapTypes: MYSQL_LARGE_TYPES },
     mariadb: { expressions: { ...MYSQL, uuidv7: 'UUID_v7()' }, wrapTypes: MYSQL_LARGE_TYPES },
     sqlite: { expressions: ANSI },
+    // `SYSUTCDATETIME()` over `CURRENT_TIMESTAMP`, which is local time in the server's zone. No
+    // `uuidv7`: `NEWSEQUENTIALID()` is an ordered v4 GUID, so it carries no readable timestamp and
+    // does not sort the way a v7 does elsewhere - a `uuidv7()` default is refused rather than served
+    // something that only looks like one.
+    mssql: { expressions: { ...ANSI, now: 'SYSUTCDATETIME()', uuid: 'NEWID()' } },
 };
 /**
  * A DDL default that is SQL rather than a literal. A class, not a plain object, so a JSON default

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

@@ -1,11 +1,19 @@
 import type { AbstractSqlDialect } from '../../dialect/abstractSqlDialect.js';
 import { IndexDdl } from './indexDdl.js';
+import { TableDdl } from './tableDdl.js';
 export { IndexDdl } from './indexDdl.js';
+export { MsSqlTableDdl } from './mssqlTableDdl.js';
 export { MariaIndexDdl, MySqlIndexDdl, MysqlLikeIndexDdl } from './mysqlIndexDdl.js';
 export { CockroachIndexDdl, PgIndexDdl } from './pgIndexDdl.js';
+export { TableDdl } from './tableDdl.js';
 /**
  * The index DDL a dialect gets, most specific first. `instanceof` rather than `dialectName` so a
  * dialect subclassed by a user keeps its family's DDL, which is what overriding gave it while this
  * lived on the dialect itself. Anything else gets the portable form, which is SQLite's.
  */
 export declare function indexDdlFor(dialect: AbstractSqlDialect): IndexDdl;
+/**
+ * The table DDL a dialect gets: SQL Server's, or the portable form every other engine takes. By
+ * `dialectName`, which a subclass inherits too, so this entry need not carry the dialect itself.
+ */
+export declare function tableDdlFor(dialect: AbstractSqlDialect): TableDdl;

package/dist/migrate/ddl/index.js

@@ -4,11 +4,15 @@ import { PgLikeSqlDialect } from '../../dialect/pgLikeSqlDialect.js';
 import { MariaDialect } from '../../maria/mariaDialect.js';
 import { MySqlDialect } from '../../mysql/mysqlDialect.js';
 import { IndexDdl } from './indexDdl.js';
+import { MsSqlTableDdl } from './mssqlTableDdl.js';
 import { MariaIndexDdl, MySqlIndexDdl, MysqlLikeIndexDdl } from './mysqlIndexDdl.js';
 import { CockroachIndexDdl, PgIndexDdl } from './pgIndexDdl.js';
+import { TableDdl } from './tableDdl.js';
 export { IndexDdl } from './indexDdl.js';
+export { MsSqlTableDdl } from './mssqlTableDdl.js';
 export { MariaIndexDdl, MySqlIndexDdl, MysqlLikeIndexDdl } from './mysqlIndexDdl.js';
 export { CockroachIndexDdl, PgIndexDdl } from './pgIndexDdl.js';
+export { TableDdl } from './tableDdl.js';
 /**
  * The index DDL a dialect gets, most specific first. `instanceof` rather than `dialectName` so a
  * dialect subclassed by a user keeps its family's DDL, which is what overriding gave it while this
@@ -32,3 +36,10 @@ export function indexDdlFor(dialect) {
     }
     return new IndexDdl(dialect);
 }
+/**
+ * The table DDL a dialect gets: SQL Server's, or the portable form every other engine takes. By
+ * `dialectName`, which a subclass inherits too, so this entry need not carry the dialect itself.
+ */
+export function tableDdlFor(dialect) {
+    return dialect.dialectName === 'mssql' ? new MsSqlTableDdl(dialect) : new TableDdl(dialect);
+}

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

@@ -0,0 +1,23 @@
+import type { ColumnSchema } from '../../type/index.js';
+import { TableDdl } from './tableDdl.js';
+/**
+ * SQL Server keeps a column's `DEFAULT`, `CHECK` and `UNIQUE` as constraints under names it picks, and
+ * refuses to drop or retype the column past one, so they go first - looked up by column, as no two
+ * databases name them alike. Renames are `sp_rename`, T-SQL having no `RENAME` clause.
+ */
+export declare class MsSqlTableDdl extends TableDdl {
+    /** T-SQL rejects the optional `COLUMN` keyword after `ADD`. */
+    addColumn(table: string, definition: string): string;
+    /** Its constraints go with the column, as they do on every other engine. */
+    dropColumn(table: string, column: string): string[];
+    /**
+     * `ALTER COLUMN` takes the type and nullability alone, so the default is dropped and added back as a
+     * constraint of its own. A `CHECK` or `UNIQUE` stays, and the server refuses a retype it blocks.
+     */
+    alterColumn(table: string, column: ColumnSchema): string[];
+    renameColumn(table: string, oldName: string, newName: string): string;
+    renameTable(oldName: string, newName: string): string;
+    storedGeneratedColumn(_type: string, expression: string): string;
+    /** One statement, so a split on `;` cannot part the lookup from the `EXEC` it feeds. */
+    private dropConstraints;
+}

package/dist/migrate/ddl/mssqlTableDdl.js

@@ -0,0 +1,61 @@
+import { escapeSingleQuotes } from '../../util/sqlLiteral.js';
+import { sizedType, TableDdl } from './tableDdl.js';
+/** The constraints of each kind on column `c`, the `sys.columns` row {@link MsSqlTableDdl} reads. */
+const CONSTRAINTS_ON = {
+    default: /*sql*/ `SELECT d.name FROM sys.default_constraints d
+    WHERE d.parent_object_id = c.object_id AND d.parent_column_id = c.column_id`,
+    check: /*sql*/ `SELECT k.name FROM sys.check_constraints k
+    WHERE k.parent_object_id = c.object_id AND k.parent_column_id = c.column_id`,
+    unique: /*sql*/ `SELECT u.name FROM sys.key_constraints u
+    JOIN sys.index_columns ic ON ic.object_id = u.parent_object_id AND ic.index_id = u.unique_index_id
+    WHERE u.parent_object_id = c.object_id AND u.type = 'UQ' AND ic.column_id = c.column_id`,
+};
+/**
+ * SQL Server keeps a column's `DEFAULT`, `CHECK` and `UNIQUE` as constraints under names it picks, and
+ * refuses to drop or retype the column past one, so they go first - looked up by column, as no two
+ * databases name them alike. Renames are `sp_rename`, T-SQL having no `RENAME` clause.
+ */
+export class MsSqlTableDdl extends TableDdl {
+    /** T-SQL rejects the optional `COLUMN` keyword after `ADD`. */
+    addColumn(table, definition) {
+        return /*sql*/ `ALTER TABLE ${this.dialect.escapeId(table)} ADD ${definition};`;
+    }
+    /** Its constraints go with the column, as they do on every other engine. */
+    dropColumn(table, column) {
+        return [this.dropConstraints(table, column, Object.values(CONSTRAINTS_ON)), ...super.dropColumn(table, column)];
+    }
+    /**
+     * `ALTER COLUMN` takes the type and nullability alone, so the default is dropped and added back as a
+     * constraint of its own. A `CHECK` or `UNIQUE` stays, and the server refuses a retype it blocks.
+     */
+    alterColumn(table, column) {
+        const target = this.dialect.escapeId(table);
+        const name = this.dialect.escapeId(column.name);
+        const statements = [
+            this.dropConstraints(table, column.name, [CONSTRAINTS_ON.default]),
+            /*sql*/ `ALTER TABLE ${target} ALTER COLUMN ${name} ${sizedType(column)} ${column.nullable ? 'NULL' : 'NOT NULL'};`,
+        ];
+        if (column.defaultValue !== undefined) {
+            statements.push(/*sql*/ `ALTER TABLE ${target} ADD${this.defaultClause(column)} FOR ${name};`);
+        }
+        return statements;
+    }
+    renameColumn(table, oldName, newName) {
+        const qualified = `${this.dialect.escapeId(table)}.${this.dialect.escapeId(oldName)}`;
+        return /*sql*/ `EXEC sp_rename ${this.dialect.escape(qualified)}, ${this.dialect.escape(newName)}, 'COLUMN';`;
+    }
+    renameTable(oldName, newName) {
+        return /*sql*/ `EXEC sp_rename ${this.dialect.escape(this.dialect.escapeId(oldName))}, ${this.dialect.escape(newName)};`;
+    }
+    storedGeneratedColumn(_type, expression) {
+        return /*sql*/ `AS (${expression}) PERSISTED`;
+    }
+    /** One statement, so a split on `;` cannot part the lookup from the `EXEC` it feeds. */
+    dropConstraints(table, column, kinds) {
+        const target = this.dialect.escapeId(table);
+        return (`DECLARE @drop nvarchar(max) = (SELECT STRING_AGG(N'ALTER TABLE ${escapeSingleQuotes(target)} DROP CONSTRAINT ' ` +
+            `+ QUOTENAME(pinned.name), N'; ') FROM sys.columns c CROSS APPLY (${kinds.join(' UNION ALL ')}) pinned ` +
+            `WHERE c.object_id = OBJECT_ID(${this.dialect.escape(target)}) AND c.name = ${this.dialect.escape(column)}) ` +
+            'EXEC (@drop);');
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { AbstractSqlDialect } from '../../dialect/abstractSqlDialect.js';
+import type { ColumnSchema } from '../../type/index.js';
+/**
+ * A column's type with the size it was read back with, unless its spelling already carries one:
+ * introspection reports `VARCHAR` and `255` apart, where a type from an entity is already whole.
+ */
+export declare function sizedType(column: Pick<ColumnSchema, 'type' | 'length' | 'precision' | 'scale'>): string;
+/**
+ * The `ALTER TABLE` statements an engine spells its own way: the migrator's, for the reason
+ * {@link IndexDdl} is. The form here is the portable one; SQL Server's is {@link MsSqlTableDdl}.
+ */
+export declare class TableDdl {
+    protected readonly dialect: AbstractSqlDialect;
+    constructor(dialect: AbstractSqlDialect);
+    addColumn(table: string, definition: string): string;
+    dropColumn(table: string, column: string): string[];
+    /**
+     * What changes `column` to what it now declares. `definition` is the whole column, which MySQL's
+     * `MODIFY COLUMN` restates; Postgres takes each change as a clause of its own.
+     */
+    alterColumn(table: string, column: ColumnSchema, definition: string): string[];
+    renameColumn(table: string, oldName: string, newName: string): string;
+    renameTable(oldName: string, newName: string): string;
+    /** A stored generated column's type, with the clause computing it. */
+    storedGeneratedColumn(type: string, expression: string): string;
+    /**
+     * ` DEFAULT <sql>`, or nothing where the column declares none. Empty rather than `DEFAULT NULL`, so
+     * an absent default stays absent - `defaultValue: null` is the way to ask for one.
+     */
+    defaultClause(column: {
+        readonly defaultValue?: unknown;
+        readonly type: string;
+    }): string;
+}

package/dist/migrate/ddl/tableDdl.js

@@ -0,0 +1,71 @@
+import { formatDefaultValue } from '../builder/expressions.js';
+/**
+ * A column's type with the size it was read back with, unless its spelling already carries one:
+ * introspection reports `VARCHAR` and `255` apart, where a type from an entity is already whole.
+ */
+export function sizedType(column) {
+    if (column.type.includes('(')) {
+        return column.type;
+    }
+    if (column.precision !== undefined) {
+        const size = column.scale === undefined ? column.precision : `${column.precision}, ${column.scale}`;
+        return `${column.type}(${size})`;
+    }
+    return column.length === undefined ? column.type : `${column.type}(${column.length})`;
+}
+/**
+ * The `ALTER TABLE` statements an engine spells its own way: the migrator's, for the reason
+ * {@link IndexDdl} is. The form here is the portable one; SQL Server's is {@link MsSqlTableDdl}.
+ */
+export class TableDdl {
+    dialect;
+    constructor(dialect) {
+        this.dialect = dialect;
+    }
+    addColumn(table, definition) {
+        return `ALTER TABLE ${this.dialect.escapeId(table)} ADD COLUMN ${definition};`;
+    }
+    dropColumn(table, column) {
+        return [`ALTER TABLE ${this.dialect.escapeId(table)} DROP COLUMN ${this.dialect.escapeId(column)};`];
+    }
+    /**
+     * What changes `column` to what it now declares. `definition` is the whole column, which MySQL's
+     * `MODIFY COLUMN` restates; Postgres takes each change as a clause of its own.
+     */
+    alterColumn(table, column, definition) {
+        if (this.dialect.alterColumnSyntax === 'none') {
+            throw new TypeError(`${this.dialect}: Cannot alter column "${column.name}" - you must recreate the table. ` +
+                `This database does not support ALTER COLUMN.`);
+        }
+        const target = this.dialect.escapeId(table);
+        if (this.dialect.alterColumnStrategy !== 'separate-clauses') {
+            return [`ALTER TABLE ${target} ${this.dialect.alterColumnSyntax} ${definition};`];
+        }
+        const alter = `ALTER TABLE ${target} ALTER COLUMN ${this.dialect.escapeId(column.name)}`;
+        return [
+            `${alter} TYPE ${column.type};`,
+            `${alter} ${column.nullable ? 'DROP NOT NULL' : 'SET NOT NULL'};`,
+            column.defaultValue === undefined ? `${alter} DROP DEFAULT;` : `${alter} SET${this.defaultClause(column)};`,
+        ];
+    }
+    renameColumn(table, oldName, newName) {
+        const [target, from, to] = [table, oldName, newName].map((name) => this.dialect.escapeId(name));
+        return `ALTER TABLE ${target} RENAME COLUMN ${from} TO ${to};`;
+    }
+    renameTable(oldName, newName) {
+        return `ALTER TABLE ${this.dialect.escapeId(oldName)} RENAME TO ${this.dialect.escapeId(newName)};`;
+    }
+    /** A stored generated column's type, with the clause computing it. */
+    storedGeneratedColumn(type, expression) {
+        return `${type} GENERATED ALWAYS AS (${expression}) STORED`;
+    }
+    /**
+     * ` DEFAULT <sql>`, or nothing where the column declares none. Empty rather than `DEFAULT NULL`, so
+     * an absent default stays absent - `defaultValue: null` is the way to ask for one.
+     */
+    defaultClause(column) {
+        return column.defaultValue === undefined
+            ? ''
+            : ` DEFAULT ${formatDefaultValue(column.defaultValue, this.dialect, column.type)}`;
+    }
+}

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

@@ -1,5 +1,7 @@
 export * from './abstractSqlSchemaIntrospector.js';
 export * from './mongoIntrospector.js';
+export * from './mssqlIntrospector.js';
 export { MariadbSchemaIntrospector, MysqlSchemaIntrospector } from './mysqlIntrospector.js';
 export * from './postgresIntrospector.js';
 export * from './sqliteIntrospector.js';
+export { introspectorFor } from './registry.js';

package/dist/migrate/introspection/index.js

@@ -1,5 +1,7 @@
 export * from './abstractSqlSchemaIntrospector.js';
 export * from './mongoIntrospector.js';
+export * from './mssqlIntrospector.js';
 export { MariadbSchemaIntrospector, MysqlSchemaIntrospector } from './mysqlIntrospector.js';
 export * from './postgresIntrospector.js';
 export * from './sqliteIntrospector.js';
+export { introspectorFor } from './registry.js';

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

@@ -0,0 +1,60 @@
+import type { ColumnSchema, ForeignKeySchema, IndexSchema } from '../../type/index.js';
+import { AbstractSqlSchemaIntrospector, type TableRowReader } from './abstractSqlSchemaIntrospector.js';
+/**
+ * SQL Server schema introspector.
+ *
+ * `INFORMATION_SCHEMA` answers columns and foreign keys, but not indexes: it has no view for them at
+ * all, and its `CONSTRAINT_COLUMN_USAGE` conflates a unique index with a unique constraint. Those
+ * come from `sys.indexes` instead, which is also the only place the filtered-index predicate and the
+ * included columns are readable.
+ */
+export declare class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
+    protected readonly defaultSchemaExpr = "SCHEMA_NAME()";
+    protected getTableNamesQuery(): string;
+    protected tableExistsQuery(): string;
+    protected parseTableExistsResult(results: {
+        count?: number;
+    }[]): boolean;
+    /**
+     * From `sys` rather than `INFORMATION_SCHEMA`, which has no identity flag and no per-column view of
+     * the key or of a unique index. A key column is not also `isUnique`, as on MySQL: only a unique index
+     * of its own, other than the key's, makes it so.
+     */
+    protected getColumnsQuery(_tableName: string): string;
+    /** `is_primary_key` is excluded: the key is read separately, the way every other engine reads it. */
+    protected getIndexesQuery(_tableName: string): string;
+    protected getForeignKeysQuery(_tableName: string): string;
+    protected getPrimaryKeyQuery(_tableName: string): string;
+    protected mapColumnsResult(_read: TableRowReader, _tableName: string, results: MsSqlColumnRow[]): Promise<ColumnSchema[]>;
+    protected mapIndexesResult(_read: TableRowReader, _tableName: string, results: {
+        index_name: string;
+        columns: string;
+        is_unique: boolean;
+    }[]): 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[]>;
+    /**
+     * 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.
+     */
+    protected parseDefaultValue(defaultValue: string | null): unknown;
+}
+type MsSqlColumnRow = {
+    column_name: string;
+    data_type: string;
+    max_length: number | null;
+    numeric_precision: number | null;
+    numeric_scale: number | null;
+    is_nullable: boolean;
+    is_identity: boolean;
+    column_default: string | null;
+    is_primary_key: number | null;
+    is_unique: number | null;
+};
+export {};