uql-orm 0.51.0 → 0.52.0

package/dist/postgres/pgCursorStream.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Runs one statement of the cursor protocol. `internalAll` for every caller so far: the cursor holds
+ * a connection's session state, so it must be the querier's own connection, and it must not go
+ * through `all()`, whose `serialize` is not re-entrant.
+ */
+export type CursorExecutor<T> = (query: string, values?: unknown[]) => Promise<T[]>;
+/**
+ * Stream a Postgres-wire result through a server-side cursor, for a driver whose client exposes none:
+ * `bun:sql` (no cursor API at all, [oven-sh/bun#17181](https://github.com/oven-sh/bun/issues/17181))
+ * and PGlite. `pg` has `pg-query-stream` and keeps using it.
+ *
+ * `DECLARE` is only legal inside a transaction, so one is opened here when the caller has none - and
+ * then committed, or rolled back if the stream failed. That `BEGIN` goes straight to the connection
+ * rather than through `beginTransaction`, so the querier's own transaction state stays untouched:
+ * this one is the generator's, and ends with it.
+ *
+ * The cleanup lives in `finally` because a consumer that stops early (`break`, a `throw` downstream)
+ * ends the generator there and nowhere else, and an abandoned cursor holds its transaction open.
+ */
+export declare function streamViaCursor<T>(exec: CursorExecutor<T>, query: string, values?: unknown[], inTransaction?: boolean): AsyncIterable<T>;

package/dist/postgres/pgCursorStream.js

@@ -0,0 +1,49 @@
+/** The cursor a stream declares. Suffixed per call, so two streams on one connection cannot collide. */
+const CURSOR_ALIAS = '_uql_cursor';
+/** Rows per round trip, matching `pg-query-stream`'s own default so both paths read the same. */
+const FETCH_SIZE = 100;
+let cursorSeq = 0;
+/**
+ * Stream a Postgres-wire result through a server-side cursor, for a driver whose client exposes none:
+ * `bun:sql` (no cursor API at all, [oven-sh/bun#17181](https://github.com/oven-sh/bun/issues/17181))
+ * and PGlite. `pg` has `pg-query-stream` and keeps using it.
+ *
+ * `DECLARE` is only legal inside a transaction, so one is opened here when the caller has none - and
+ * then committed, or rolled back if the stream failed. That `BEGIN` goes straight to the connection
+ * rather than through `beginTransaction`, so the querier's own transaction state stays untouched:
+ * this one is the generator's, and ends with it.
+ *
+ * The cleanup lives in `finally` because a consumer that stops early (`break`, a `throw` downstream)
+ * ends the generator there and nowhere else, and an abandoned cursor holds its transaction open.
+ */
+export async function* streamViaCursor(exec, query, values, inTransaction = false) {
+    const cursor = `${CURSOR_ALIAS}_${++cursorSeq}`;
+    const ownsTransaction = !inTransaction;
+    if (ownsTransaction) {
+        await exec('BEGIN');
+    }
+    let failed = false;
+    try {
+        await exec(`DECLARE ${cursor} CURSOR FOR ${query}`, values);
+        for (;;) {
+            const rows = await exec(`FETCH FORWARD ${FETCH_SIZE} FROM ${cursor}`);
+            yield* rows;
+            if (rows.length < FETCH_SIZE) {
+                return;
+            }
+        }
+    }
+    catch (err) {
+        failed = true;
+        throw err;
+    }
+    finally {
+        // Best-effort once the stream has failed: an error raised here would replace the one that brought
+        // us here, which is the one worth reporting, and the rollback discards the cursor either way.
+        const end = failed ? (sql) => exec(sql).catch(() => []) : exec;
+        await end(`CLOSE ${cursor}`);
+        if (ownsTransaction) {
+            await end(failed ? 'ROLLBACK' : 'COMMIT');
+        }
+    }
+}

package/dist/postgres/pgDialect.d.ts

@@ -4,7 +4,7 @@ import { PostgresDialect } from './postgresDialect.js';
  *
  * @remarks Uses base {@link PostgresDialect} capabilities: native JS arrays for `ANY` / `ALL`
  * (`nativeArrays: true`) and `$n::jsonb` without a text re-cast. Bun SQL Postgres needs
- * `BunSqlPostgresDialect` from `uql-orm/bunSql` instead (wire array literals + text json cast).
+ * `BunSqlQuerierPool` from `uql-orm/bunSql` instead (wire array literals + text json cast).
  */
 export declare class PgDialect extends PostgresDialect {
 }

package/dist/postgres/pgDialect.js

@@ -4,7 +4,7 @@ import { PostgresDialect } from './postgresDialect.js';
  *
  * @remarks Uses base {@link PostgresDialect} capabilities: native JS arrays for `ANY` / `ALL`
  * (`nativeArrays: true`) and `$n::jsonb` without a text re-cast. Bun SQL Postgres needs
- * `BunSqlPostgresDialect` from `uql-orm/bunSql` instead (wire array literals + text json cast).
+ * `BunSqlQuerierPool` from `uql-orm/bunSql` instead (wire array literals + text json cast).
  */
 export class PgDialect extends PostgresDialect {
 }

package/dist/postgres/postgresWireDriverCapabilities.d.ts

@@ -1,19 +1,21 @@
 /**
- * Wire-style parameter shaping for **Bun SQL** (and similar clients) on any Postgres-wire dialect:
- * arrays are sent as string literals (`nativeArrays: false`) via {@link PgLikeSqlDialect}'s
- * `toPgArray` path.
+ * Driver-shaped parameter handling for **Bun SQL** (and any client like it) on a Postgres-wire
+ * dialect: arrays go as string literals (`nativeArrays: false`, {@link PgLikeSqlDialect}'s `toPgArray`
+ * path) and a JSON bind is re-cast through text (`explicitJsonCast: true`). Both are measured, on a
+ * live server: `bun:sql` binds neither `sql.array(...)` nor a plain JS array through `unsafe()`
+ * (verified again on Bun 1.4.2), and without the text re-cast a `$set`/`$push` on a JSONB column
+ * silently writes the wrong value or throws - on Postgres and, identically, on CockroachDB, which
+ * `bun:sql` reaches through its own Postgres wire implementation.
  *
- * `PgDialect` does **not** use this constant - it keeps base {@link PgLikeSqlDialect} defaults
- * (`nativeArrays: true`, `explicitJsonCast: false`), since node-`pg` doesn't need the fix.
- * `BunSqlPostgresDialect` and `BunSqlCockroachDialect` both spread this and set
- * `explicitJsonCast: true` - `bun:sql` routes CockroachDB through its own Postgres wire-protocol
- * implementation (see `bunSql.util.ts#normalizeBunOpts`), so it needs the identical fix: verified
- * directly that without it, `$set`/`$push` on a JSONB column silently produce the wrong value
- * or throw on a live CockroachDB instance.
+ * The pair is one constant because it is one driver's shape, and `BunSqlQuerierPool` hands it to
+ * `PostgresDialect`/`CockroachDialect` as their `driverCapabilities` rather than subclassing either:
+ * Bun changes how a parameter binds, never the SQL. `PgDialect` uses neither, keeping the base
+ * {@link PgLikeSqlDialect} defaults, since node-`pg` needs no fix.
  *
  * @remarks Optional import for custom pools. Neon uses its own serverless driver (not `bun:sql`),
  * so `NeonDialect` is a separate, unverified case - do not assume it needs this without testing.
  */
 export declare const POSTGRES_WIRE_DRIVER_CAPABILITIES: {
     readonly nativeArrays: false;
+    readonly explicitJsonCast: true;
 };

package/dist/postgres/postgresWireDriverCapabilities.js

@@ -1,19 +1,21 @@
 /**
- * Wire-style parameter shaping for **Bun SQL** (and similar clients) on any Postgres-wire dialect:
- * arrays are sent as string literals (`nativeArrays: false`) via {@link PgLikeSqlDialect}'s
- * `toPgArray` path.
+ * Driver-shaped parameter handling for **Bun SQL** (and any client like it) on a Postgres-wire
+ * dialect: arrays go as string literals (`nativeArrays: false`, {@link PgLikeSqlDialect}'s `toPgArray`
+ * path) and a JSON bind is re-cast through text (`explicitJsonCast: true`). Both are measured, on a
+ * live server: `bun:sql` binds neither `sql.array(...)` nor a plain JS array through `unsafe()`
+ * (verified again on Bun 1.4.2), and without the text re-cast a `$set`/`$push` on a JSONB column
+ * silently writes the wrong value or throws - on Postgres and, identically, on CockroachDB, which
+ * `bun:sql` reaches through its own Postgres wire implementation.
  *
- * `PgDialect` does **not** use this constant - it keeps base {@link PgLikeSqlDialect} defaults
- * (`nativeArrays: true`, `explicitJsonCast: false`), since node-`pg` doesn't need the fix.
- * `BunSqlPostgresDialect` and `BunSqlCockroachDialect` both spread this and set
- * `explicitJsonCast: true` - `bun:sql` routes CockroachDB through its own Postgres wire-protocol
- * implementation (see `bunSql.util.ts#normalizeBunOpts`), so it needs the identical fix: verified
- * directly that without it, `$set`/`$push` on a JSONB column silently produce the wrong value
- * or throw on a live CockroachDB instance.
+ * The pair is one constant because it is one driver's shape, and `BunSqlQuerierPool` hands it to
+ * `PostgresDialect`/`CockroachDialect` as their `driverCapabilities` rather than subclassing either:
+ * Bun changes how a parameter binds, never the SQL. `PgDialect` uses neither, keeping the base
+ * {@link PgLikeSqlDialect} defaults, since node-`pg` needs no fix.
  *
  * @remarks Optional import for custom pools. Neon uses its own serverless driver (not `bun:sql`),
  * so `NeonDialect` is a separate, unverified case - do not assume it needs this without testing.
  */
 export const POSTGRES_WIRE_DRIVER_CAPABILITIES = {
     nativeArrays: false,
+    explicitJsonCast: true,
 };

package/dist/schema/canonicalType.js

@@ -44,6 +44,9 @@ const SQL_TO_CANONICAL = {
     char: { category: 'string' },
     character: { category: 'string' },
     varchar: { category: 'string' },
+    varchar2: { category: 'string' },
+    nvarchar: { category: 'string' },
+    nchar: { category: 'string' },
     'character varying': { category: 'string' },
     text: { category: 'string', size: 'small' },
     tinytext: { category: 'string', size: 'tiny' },
@@ -64,11 +67,15 @@ const SQL_TO_CANONICAL = {
     'timestamp with time zone': { category: 'timestamp', withTimezone: true },
     timestamptz: { category: 'timestamp', withTimezone: true },
     datetime: { category: 'timestamp' },
+    datetime2: { category: 'timestamp' },
+    smalldatetime: { category: 'timestamp' },
+    datetimeoffset: { category: 'timestamp', withTimezone: true },
     // === JSON ===
     json: { category: 'json' },
     jsonb: { category: 'json' },
     // === UUID ===
     uuid: { category: 'uuid' },
+    uniqueidentifier: { category: 'uuid' },
     // === Binary ===
     blob: { category: 'blob' },
     bytea: { category: 'blob' },
@@ -77,15 +84,16 @@ const SQL_TO_CANONICAL = {
     tinyblob: { category: 'blob', size: 'tiny' },
     mediumblob: { category: 'blob', size: 'medium' },
     longblob: { category: 'blob', size: 'big' },
+    image: { category: 'blob', size: 'big' },
     // === Vector (for AI/embeddings) ===
     vector: { category: 'vector' },
     halfvec: { category: 'halfvec' },
     sparsevec: { category: 'sparsevec' },
 };
 /**
- * pgvector is the only engine with three vector column types, so every other dialect maps all three
- * canonical categories onto the single type it does have (see `hasNarrowVectorTypes` on the dialect, the
- * dialect-side half of the same fact).
+ * pgvector is the only engine with three vector column types, so every other engine maps all three
+ * canonical categories onto the single type it does have (see `hasNarrowVectorTypes` on the dialect,
+ * the dialect-side half of the same fact).
  */
 function withVectorType(scalars, vector) {
     return { ...scalars, vector, halfvec: vector, sparsevec: vector };
@@ -103,11 +111,9 @@ const PG_SCALAR_MAP = {
     uuid: 'UUID',
     blob: 'BYTEA',
 };
-const PG_TYPE_MAP = {
-    ...PG_SCALAR_MAP,
-    vector: 'VECTOR',
-    halfvec: 'HALFVEC',
-    sparsevec: 'SPARSEVEC',
+const PG_SIZES = {
+    integer: { tiny: 'SMALLINT', small: 'SMALLINT', medium: 'INTEGER', big: 'BIGINT' },
+    float: { tiny: 'REAL', small: 'REAL', medium: 'DOUBLE PRECISION', big: 'DOUBLE PRECISION' },
 };
 const MYSQL_SCALAR_MAP = {
     integer: 'INT',
@@ -122,6 +128,13 @@ const MYSQL_SCALAR_MAP = {
     uuid: 'CHAR(36)',
     blob: 'BLOB',
 };
+/** MariaDB is a MySQL fork and spells every one of these the same way, so both take the one map. */
+const MYSQL_SIZES = {
+    integer: { tiny: 'TINYINT', small: 'SMALLINT', medium: 'MEDIUMINT', big: 'BIGINT' },
+    float: { tiny: 'FLOAT', small: 'FLOAT', medium: 'DOUBLE', big: 'DOUBLE' },
+    string: { tiny: 'TINYTEXT', small: 'TEXT', medium: 'MEDIUMTEXT', big: 'LONGTEXT' },
+    blob: { tiny: 'TINYBLOB', small: 'BLOB', medium: 'MEDIUMBLOB', big: 'LONGBLOB' },
+};
 const SQLITE_SCALAR_MAP = {
     integer: 'INTEGER',
     float: 'REAL',
@@ -135,6 +148,35 @@ const SQLITE_SCALAR_MAP = {
     uuid: 'TEXT',
     blob: 'BLOB',
 };
+/**
+ * Every string column is `NVARCHAR`: `VARCHAR` is a codepage type on SQL Server and silently destroys
+ * anything outside it on write. UQL never exposes the choice, so there is nothing to weigh per column.
+ */
+const MSSQL_SCALAR_MAP = {
+    integer: 'INT',
+    float: 'REAL',
+    decimal: 'DECIMAL',
+    string: 'NVARCHAR',
+    boolean: 'BIT',
+    date: 'DATE',
+    time: 'TIME',
+    timestamp: 'DATETIME2',
+    json: 'NVARCHAR(MAX)',
+    uuid: 'UNIQUEIDENTIFIER',
+    blob: 'VARBINARY(MAX)',
+};
+/** `FLOAT` is eight bytes here and `REAL` four - the opposite of the MySQL family's spelling. */
+const MSSQL_SIZES = {
+    integer: { tiny: 'TINYINT', small: 'SMALLINT', medium: 'INT', big: 'BIGINT' },
+    float: { tiny: 'REAL', small: 'REAL', medium: 'FLOAT', big: 'FLOAT' },
+    string: { tiny: 'NVARCHAR(255)', small: 'NVARCHAR(MAX)', medium: 'NVARCHAR(MAX)', big: 'NVARCHAR(MAX)' },
+    blob: {
+        tiny: 'VARBINARY(255)',
+        small: 'VARBINARY(MAX)',
+        medium: 'VARBINARY(MAX)',
+        big: 'VARBINARY(MAX)',
+    },
+};
 /** MongoDB uses BSON types, not SQL types. These are placeholders for compatibility. */
 const MONGO_SCALAR_MAP = {
     integer: 'int',
@@ -149,73 +191,31 @@ const MONGO_SCALAR_MAP = {
     uuid: 'binData',
     blob: 'binData',
 };
-/** Every engine's scalars, and the one spelling it gives all three vector widths. */
-const CANONICAL_TO_SQL = {
-    postgres: PG_TYPE_MAP,
+/** Every engine's spelling of the canonical types. A new engine is one entry here and nothing else. */
+const ENGINE_TYPES = {
+    postgres: {
+        scalars: { ...PG_SCALAR_MAP, vector: 'VECTOR', halfvec: 'HALFVEC', sparsevec: 'SPARSEVEC' },
+        sizes: PG_SIZES,
+    },
     // CockroachDB's VECTOR is native, no extension needed.
-    cockroachdb: withVectorType(PG_SCALAR_MAP, 'VECTOR'),
+    cockroachdb: { scalars: withVectorType(PG_SCALAR_MAP, 'VECTOR'), sizes: PG_SIZES },
     // MySQL does have a `VECTOR` type (26.7), but no distance function outside HeatWave and no vector
     // index, so JSON keeps the column queryable with the JSON operators and needs no conversion.
-    mysql: withVectorType(MYSQL_SCALAR_MAP, 'JSON'),
-    mariadb: withVectorType(MYSQL_SCALAR_MAP, 'VECTOR'),
-    sqlite: withVectorType(SQLITE_SCALAR_MAP, 'TEXT'),
-    mongodb: withVectorType(MONGO_SCALAR_MAP, 'array'),
-};
-/**
- * Size variant modifiers for SQL types.
- */
-const PG_SIZE_MODIFIERS = {
-    integer: {
-        tiny: 'SMALLINT',
-        small: 'SMALLINT',
-        medium: 'INTEGER',
-        big: 'BIGINT',
-    },
-    float: {
-        tiny: 'REAL',
-        small: 'REAL',
-        medium: 'DOUBLE PRECISION',
-        big: 'DOUBLE PRECISION',
-    },
-};
-/**
- * MariaDB is a MySQL fork and spells every one of these the same way, so both take the one map.
- * Listed per-dialect, MariaDB's had only `integer`: a `double` column was created `FLOAT` there, four
- * bytes where the entity asked for eight, and a `big` string or blob lost its `LONG` prefix.
- */
-const MYSQL_SIZE_MODIFIERS = {
-    integer: {
-        tiny: 'TINYINT',
-        small: 'SMALLINT',
-        medium: 'MEDIUMINT',
-        big: 'BIGINT',
+    mysql: {
+        scalars: withVectorType(MYSQL_SCALAR_MAP, 'JSON'),
+        sizes: MYSQL_SIZES,
+        decimal: { precision: 10, scale: 2 },
     },
-    float: {
-        tiny: 'FLOAT',
-        small: 'FLOAT',
-        medium: 'DOUBLE',
-        big: 'DOUBLE',
+    mariadb: {
+        scalars: withVectorType(MYSQL_SCALAR_MAP, 'VECTOR'),
+        sizes: MYSQL_SIZES,
+        decimal: { precision: 10, scale: 2 },
     },
-    string: {
-        tiny: 'TINYTEXT',
-        small: 'TEXT',
-        medium: 'MEDIUMTEXT',
-        big: 'LONGTEXT',
-    },
-    blob: {
-        tiny: 'TINYBLOB',
-        small: 'BLOB',
-        medium: 'MEDIUMBLOB',
-        big: 'LONGBLOB',
-    },
-};
-const SIZE_MODIFIERS = {
-    postgres: PG_SIZE_MODIFIERS,
-    cockroachdb: PG_SIZE_MODIFIERS,
-    mysql: MYSQL_SIZE_MODIFIERS,
-    sqlite: {}, // SQLite uses affinity, no size modifiers
-    mariadb: MYSQL_SIZE_MODIFIERS,
-    mongodb: {},
+    // SQLite uses affinity, so no size variants.
+    sqlite: { scalars: withVectorType(SQLITE_SCALAR_MAP, 'TEXT') },
+    // A 2025 server has a native `VECTOR`; below that the column is JSON text, which stays queryable.
+    mssql: { scalars: withVectorType(MSSQL_SCALAR_MAP, 'NVARCHAR(MAX)'), sizes: MSSQL_SIZES },
+    mongodb: { scalars: withVectorType(MONGO_SCALAR_MAP, 'array') },
 };
 /**
  * Maps canonical types to TypeScript types for entity generation.
@@ -317,61 +317,44 @@ export function canonicalColumnType(sqlType, reported = {}) {
 export function canonicalToSql(type, dialect) {
     if (type.raw)
         return type.raw;
-    const dialectName = dialect.dialectName;
-    let sqlType = getBaseSqlType(type, dialectName);
-    if (type.category === 'string') {
-        sqlType = formatStringSqlType(type, dialect);
+    const engine = ENGINE_TYPES[dialect.dialectName];
+    const { features } = dialect;
+    // A `size` the engine spells out wins outright; anything else falls through to the rules below.
+    // `TEXT` canonicalizes to `size: 'small'`, so a string counts as unsized only where the engine
+    // declares no variant for it, which is how Postgres reaches `TEXT` rather than its base `VARCHAR`.
+    const sized = engine.sizes?.[type.category]?.[type.size];
+    let sqlType = sized ?? engine.scalars[type.category];
+    if (type.category === 'string' && !sized) {
+        sqlType = formatStringSqlType(type, engine.scalars.string, features.stringSizing);
     }
     else if (type.category === 'decimal') {
-        sqlType = formatDecimalSqlType(type, dialectName, sqlType);
+        sqlType = formatDecimalSqlType(type, engine.decimal, sqlType);
     }
-    else if (isVectorCategory(type.category) && type.length && dialect.features.vectorSupportsLength) {
+    else if (isVectorCategory(type.category) && type.length && features.vectorSupportsLength) {
         sqlType = `${sqlType}(${type.length})`;
     }
-    if (type.category === 'timestamp' && type.withTimezone && dialect.features.supportsTimestamptz) {
+    if (type.category === 'timestamp' && type.withTimezone && features.supportsTimestamptz) {
         sqlType = 'TIMESTAMPTZ';
     }
-    if (type.unsigned && (dialectName === 'mysql' || dialectName === 'mariadb')) {
-        sqlType = `${sqlType} UNSIGNED`;
-    }
-    return sqlType;
+    return type.unsigned && features.supportsUnsigned ? `${sqlType} UNSIGNED` : sqlType;
 }
-function getBaseSqlType(type, dialect) {
-    let sqlType = CANONICAL_TO_SQL[dialect][type.category];
-    if (type.size) {
-        const sizeMap = SIZE_MODIFIERS[dialect][type.category];
-        if (sizeMap?.[type.size]) {
-            sqlType = sizeMap[type.size];
-        }
+/** See {@link EngineFeatures.stringSizing} for what each mode means. */
+function formatStringSqlType(type, base, sizing) {
+    if (sizing === 'text') {
+        return base;
     }
-    return sqlType;
-}
-function formatStringSqlType(type, dialect) {
-    const { dialectName, features } = dialect;
-    if (dialectName === 'sqlite')
-        return 'TEXT';
-    if (features.defaultStringAsText)
-        return type.length ? `VARCHAR(${type.length})` : 'TEXT';
-    if (dialectName === 'mysql' || dialectName === 'mariadb') {
-        if (type.size === 'tiny')
-            return 'TINYTEXT';
-        if (type.size === 'small')
-            return 'TEXT';
-        if (type.size === 'medium')
-            return 'MEDIUMTEXT';
-        if (type.size === 'big')
-            return 'LONGTEXT';
-        return type.length ? `VARCHAR(${type.length})` : 'VARCHAR(255)';
+    if (type.length) {
+        return `${base}(${type.length})`;
     }
-    return type.length ? `VARCHAR(${type.length})` : 'VARCHAR(255)';
+    return sizing === 'bounded-text' ? 'TEXT' : `${base}(255)`;
 }
-function formatDecimalSqlType(type, dialect, baseType) {
-    const p = type.precision ?? (dialect === 'mysql' || dialect === 'mariadb' ? 10 : undefined);
-    const s = type.scale ?? (dialect === 'mysql' || dialect === 'mariadb' ? 2 : undefined);
-    if (p !== undefined) {
-        return s !== undefined ? `${baseType}(${p}, ${s})` : `${baseType}(${p})`;
+function formatDecimalSqlType(type, fallback, baseType) {
+    const p = type.precision ?? fallback?.precision;
+    const s = type.scale ?? fallback?.scale;
+    if (p === undefined) {
+        return baseType;
     }
-    return baseType;
+    return s === undefined ? `${baseType}(${p})` : `${baseType}(${p}, ${s})`;
 }
 /**
  * Convert a canonical type to a TypeScript type string.

package/dist/sqlite/sqliteDialect.js

@@ -19,7 +19,10 @@ export class SqliteDialect extends AbstractSqlDialect {
         vectorIndexRequiresNotNull: false,
         vectorSupportsLength: false,
         supportsTimestamptz: false,
-        defaultStringAsText: true,
+        stringSizing: 'text',
+        supportsUnsigned: false,
+        multipleCascadePaths: true,
+        serverSideCursors: false,
     };
     dialectName = 'sqlite';
     escapeIdChar = '`';

package/dist/type/dialect.d.ts

@@ -128,8 +128,35 @@ export interface EngineFeatures {
     readonly vectorSupportsLength: boolean;
     /** Whether the dialect natively supports the TIMESTAMPTZ alias/type. */
     readonly supportsTimestamptz: boolean;
-    /** Whether the dialect defaults to TEXT for strings when no length is specified (e.g. Postgres). */
-    readonly defaultStringAsText: boolean;
+    /**
+     * How a `string` column is sized: `text` is always the unbounded type whatever length was asked
+     * for (SQLite, whose affinity makes a bound meaningless), `bounded-text` takes the bound when there
+     * is one and the unbounded type otherwise (the Postgres family), `varchar` is always bounded and
+     * falls back to 255 (the MySQL family, SQL Server).
+     *
+     * Three-way for the reason {@link commentSyntax} is: a boolean puts SQLite and Postgres on the
+     * same branch, and they need different answers.
+     */
+    readonly stringSizing: 'text' | 'bounded-text' | 'varchar';
+    /** Whether the engine has unsigned integers, so `@Field({ unsigned: true })` reaches the column. */
+    readonly supportsUnsigned: boolean;
+    /**
+     * Whether one table can be reached by two cascading foreign-key paths. SQL Server refuses the
+     * constraint outright ("may cause cycles or multiple cascade paths", error 1785) and Oracle
+     * likewise, so a cascade is downgraded to `NO ACTION` there rather than emitting DDL the engine
+     * rejects - which would otherwise fail on any diamond-shaped schema at create time.
+     */
+    readonly multipleCascadePaths: boolean;
+    /**
+     * Whether the engine has SQL-level cursors (`DECLARE`/`FETCH FORWARD`/`CLOSE`), which is how a
+     * driver with no cursor API of its own still streams a result set instead of buffering it - see
+     * `postgres/pgCursorStream.ts`. True across the Postgres wire family, whose spelling that helper
+     * speaks; SQL Server and Oracle have cursors of their own but not this syntax.
+     *
+     * The node-`pg` family reports `true` and goes on using `pg-query-stream`: the flag says the engine
+     * has cursors, not that the driver needs them.
+     */
+    readonly serverSideCursors: boolean;
 }
 export interface DialectFeatures extends EngineFeatures, DriverCapabilities {
 }
@@ -219,13 +246,13 @@ export interface QueryDialect {
 /**
  * Supported SQL dialect identifiers.
  */
-export type SqlDialectName = 'postgres' | 'cockroachdb' | 'mysql' | 'mariadb' | 'sqlite';
+export type SqlDialectName = 'postgres' | 'cockroachdb' | 'mysql' | 'mariadb' | 'sqlite' | 'mssql';
 /**
  * Minimal dialect interface exposing escapeIdChar for SQL operations
  */
 export interface SqlQueryDialect extends QueryDialect {
     /**
-     * The SQL dialect name (postgres, mysql, mariadb, sqlite).
+     * The SQL dialect name (postgres, mysql, mariadb, sqlite, mssql).
      */
     readonly dialectName: SqlDialectName;
     /**

package/dist/type/migratorDialect.d.ts

@@ -1,5 +1,5 @@
 import type { DialectName } from './querier.js';
-declare const KNOWN_MIGRATOR_DIALECTS: readonly ["postgres", "cockroachdb", "mysql", "mariadb", "sqlite", "mongodb"];
+declare const KNOWN_MIGRATOR_DIALECTS: readonly ["postgres", "cockroachdb", "mysql", "mariadb", "sqlite", "mssql", "mongodb"];
 export type KnownMigratorDialect = (typeof KNOWN_MIGRATOR_DIALECTS)[number];
 /**
  * Whether `d` is supported by built-in migrator introspection / schema generators.

package/dist/type/migratorDialect.js

@@ -4,6 +4,7 @@ const KNOWN_MIGRATOR_DIALECTS = [
     'mysql',
     'mariadb',
     'sqlite',
+    'mssql',
     'mongodb',
 ];
 /**

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "uql-orm",
   "homepage": "https://uql-orm.dev",
-  "description": "The JSON-native TypeScript ORM for Bun, Browsers, Edge, Deno, Node, Workers. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
+  "description": "The JSON-native TypeScript ORM for Bun, Browsers, Edge, Deno, Node, Workers. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, SQL Server, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.51.0",
+  "version": "0.52.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -49,7 +49,8 @@
     "./pglite": "./dist/pglite/index.js",
     "./d1": "./dist/d1/index.js",
     "./bunSql": "./dist/bunSql/index.js",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./mssql": "./dist/mssql/index.js"
   },
   "files": [
     "dist",
@@ -75,6 +76,7 @@
     "express": ">=5.0.0",
     "mariadb": ">=3.0.0",
     "mongodb": ">=6.0.0",
+    "mssql": ">=11.0.0",
     "mysql2": ">=3.0.0",
     "pg": ">=8.0.0",
     "pg-query-stream": ">=4.0.0",
@@ -125,6 +127,9 @@
     },
     "rxjs": {
       "optional": true
+    },
+    "mssql": {
+      "optional": true
     }
   },
   "devDependencies": {
@@ -139,12 +144,14 @@
     "@tursodatabase/serverless": "^1.4.0",
     "@types/better-sqlite3": "^9.6.0",
     "@types/express": "^5.0.6",
+    "@types/mssql": "^12.3.0",
     "@types/pg": "^8.23.1",
     "@types/ws": "^8.18.1",
     "better-sqlite3": "^13.0.3",
     "express": "^5.2.1",
     "mariadb": "^3.5.4",
     "mongodb": "^7.6.0",
+    "mssql": "^11",
     "mysql2": "^3.24.4",
     "pg": "^8.23.0",
     "pg-query-stream": "^4.17.0",
@@ -185,6 +192,9 @@
     "sqlite",
     "sqlite3",
     "cockroachdb",
+    "mssql",
+    "sqlserver",
+    "sql-server",
     "mongodb",
     "mongo",
     "libsql",

package/dist/bunSql/bunSqlCockroachDialect.d.ts

@@ -1,12 +0,0 @@
-import { CockroachDialect } from '../cockroachdb/cockroachDialect.js';
-import type { DialectFeatures } from '../type/index.js';
-/**
- * CockroachDB Dialect specialization for the `bun:sql` driver, which routes CockroachDB
- * connections through its own Postgres wire-protocol implementation (see
- * `bunSql.util.ts#normalizeBunOpts`), so it needs the identical fix as {@link BunSqlPostgresDialect}:
- * without it, `$set`/`$push` on a JSONB column silently produce the wrong value or throw
- * (verified directly against a live CockroachDB instance via `bun:sql`).
- */
-export declare class BunSqlCockroachDialect extends CockroachDialect {
-    protected readonly featureOverrides: Partial<DialectFeatures>;
-}

package/dist/bunSql/bunSqlCockroachDialect.js

@@ -1,15 +0,0 @@
-import { CockroachDialect } from '../cockroachdb/cockroachDialect.js';
-import { POSTGRES_WIRE_DRIVER_CAPABILITIES } from '../postgres/postgresWireDriverCapabilities.js';
-/**
- * CockroachDB Dialect specialization for the `bun:sql` driver, which routes CockroachDB
- * connections through its own Postgres wire-protocol implementation (see
- * `bunSql.util.ts#normalizeBunOpts`), so it needs the identical fix as {@link BunSqlPostgresDialect}:
- * without it, `$set`/`$push` on a JSONB column silently produce the wrong value or throw
- * (verified directly against a live CockroachDB instance via `bun:sql`).
- */
-export class BunSqlCockroachDialect extends CockroachDialect {
-    featureOverrides = {
-        ...POSTGRES_WIRE_DRIVER_CAPABILITIES,
-        explicitJsonCast: true,
-    };
-}

package/dist/bunSql/bunSqlPostgresDialect.d.ts

@@ -1,11 +0,0 @@
-import { PostgresDialect } from '../postgres/postgresDialect.js';
-import type { DialectFeatures } from '../type/index.js';
-/**
- * Postgres Dialect specialization for the `bun:sql` driver.
- *
- * @remarks Reuses wire array encoding plus `explicitJsonCast` so JSON merge/push binds
- * reliably; `PgDialect` omits the text re-cast.
- */
-export declare class BunSqlPostgresDialect extends PostgresDialect {
-    protected readonly featureOverrides: Partial<DialectFeatures>;
-}