@deterministic-code/migraters 0.0.0-stage → 0.0.1

package/src/dialects/oracle-dialect.test.ts

@@ -0,0 +1,118 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const oracle = vi.hoisted(() => {
+  const state = {
+    failRollback: false,
+    closed: false,
+    executes: [] as { sql: string; params: unknown[]; opts?: object }[],
+    lastConfig: undefined as unknown,
+  };
+  const conn = {
+    async execute(sql: string, params: unknown[] = [], opts?: object) {
+      state.executes.push({ sql, params, opts });
+      if (sql.includes('NOROWS')) return {};
+      return { rows: [{ N: 1, Name: 'x' }] };
+    },
+    async commit() {},
+    async rollback() {
+      if (state.failRollback) throw new Error('rollback failed');
+    },
+    async close() {
+      state.closed = true;
+    },
+  };
+  return {
+    state,
+    OUT_FORMAT_OBJECT: 4002,
+    getConnection: async (cfg: unknown) => {
+      state.lastConfig = cfg;
+      return conn;
+    },
+  };
+});
+
+vi.mock('oracledb', () => ({
+  default: {
+    getConnection: oracle.getConnection,
+    OUT_FORMAT_OBJECT: oracle.OUT_FORMAT_OBJECT,
+  },
+}));
+
+import { OracleDialect, parseOracleConnection } from './oracle-dialect.ts';
+
+const dialect = new OracleDialect();
+
+describe('parseOracleConnection', () => {
+  it('accepts a config object or user/password@connectString', () => {
+    const obj = { user: 'u', password: 'p', connectString: 'c' };
+    expect(parseOracleConnection(obj)).toBe(obj);
+    expect(parseOracleConnection('scott/tiger@localhost/orcl')).toEqual({
+      user: 'scott',
+      password: 'tiger',
+      connectString: 'localhost/orcl',
+    });
+    expect(() => parseOracleConnection('not-a-dsn')).toThrow(
+      /Oracle connection must look like user\/password@connectString/,
+    );
+  });
+});
+
+describe('OracleDialect', () => {
+  afterEach(() => {
+    oracle.state.failRollback = false;
+    oracle.state.closed = false;
+    oracle.state.executes = [];
+    oracle.state.lastConfig = undefined;
+  });
+
+  it('registers as oracle with :n placeholders and FETCH FIRST', async () => {
+    expect(dialect.name).toBe('oracle');
+    expect([...dialect.connectionEnvironmentVariables]).toEqual([
+      'ORACLE_CONNECT_STRING',
+      'DATABASE_URL',
+    ]);
+    expect(dialect.quoteIdent('t')).toBe('"t"');
+    expect(dialect.translatePlaceholders('WHERE a = ? AND b = ?')).toBe('WHERE a = :1 AND b = :2');
+    expect(dialect.limitClause(5)).toBe('FETCH FIRST 5 ROWS ONLY');
+    expect(dialect.migratesDdl).toMatch(/migrates/i);
+    expect(dialect.migrateLogsDdl).toMatch(/migrate_logs/i);
+    expect(await dialect.prerequisiteError('u/p@c')).toBeNull();
+    await dialect.prepareSetup('u/p@c');
+  });
+
+  it('createClient parses the DSN, lowercases row keys, and commits or rolls back', async () => {
+    const client = await dialect.createClient('scott/tiger@localhost/orcl');
+    expect(client.dialect).toBe('oracle');
+    expect(oracle.state.lastConfig).toEqual({
+      user: 'scott',
+      password: 'tiger',
+      connectString: 'localhost/orcl',
+    });
+    await client.exec('ALTER SESSION SET NLS_DATE_FORMAT = "YYYY"');
+    expect(oracle.state.executes[0]?.opts).toEqual({ autoCommit: true });
+    expect(await client.query('SELECT ?', [1])).toEqual([{ n: 1, name: 'x' }]);
+    expect(await client.query('NOROWS')).toEqual([]);
+    expect(oracle.state.executes.some((e) => e.sql === 'SELECT :1')).toBe(true);
+    await client.run('UPDATE t SET x = ?', [2]);
+    expect(
+      oracle.state.executes.some((e) => e.sql === 'UPDATE t SET x = :1' && e.opts && 'autoCommit' in e.opts && e.opts.autoCommit === false),
+    ).toBe(true);
+    expect(await client.transaction(async () => 'ok')).toBe('ok');
+    await expect(
+      client.transaction(async () => {
+        throw new Error('tx');
+      }),
+    ).rejects.toThrow('tx');
+    oracle.state.failRollback = true;
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    await expect(
+      client.transaction(async () => {
+        throw new Error('tx2');
+      }),
+    ).rejects.toThrow('tx2');
+    expect(warn).toHaveBeenCalled();
+    warn.mockRestore();
+    await client.close();
+    expect(oracle.state.closed).toBe(true);
+  });
+});

package/src/dialects/oracle-dialect.ts

@@ -0,0 +1,91 @@
+import type { MigrationClient, MigrationRow } from '../migration-client.ts';
+import { interopDefault } from '../infrastructure/interop-default.ts';
+import { readSqlTemplate } from '../infrastructure/sql-templates.ts';
+import { SqlDialectBase } from '../abstractions/sql-dialect-base.ts';
+
+const [migratesDdl, migrateLogsDdl] = await Promise.all([
+  readSqlTemplate('oracle', 'migrates'),
+  readSqlTemplate('oracle', 'migrate_logs'),
+]);
+
+interface OracleConnectionConfig {
+  user: string;
+  password: string;
+  connectString: string;
+}
+
+export const parseOracleConnection = (
+  connection: string | OracleConnectionConfig,
+): OracleConnectionConfig => {
+  if (typeof connection === 'object' && connection) return connection;
+  const m = /^([^/]+)\/([^@]+)@(.+)$/.exec(String(connection));
+  if (!m) {
+    throw new Error(`Oracle connection must look like user/password@connectString`);
+  }
+  return { user: m[1] as string, password: m[2] as string, connectString: m[3] as string };
+};
+
+const lowercaseKeys = (row: MigrationRow): MigrationRow => {
+  const out: MigrationRow = {};
+  for (const [k, v] of Object.entries(row)) out[k.toLowerCase()] = v;
+  return out;
+};
+
+export class OracleDialect extends SqlDialectBase {
+  readonly name = 'oracle' as const;
+  readonly connectionEnvironmentVariables = ['ORACLE_CONNECT_STRING', 'DATABASE_URL'] as const;
+  readonly migratesDdl = migratesDdl;
+  readonly migrateLogsDdl = migrateLogsDdl;
+
+  translatePlaceholders(sql: string): string {
+    let n = 0;
+    return sql.replace(/\?/g, () => `:${++n}`);
+  }
+
+  limitClause(n: number): string {
+    return `FETCH FIRST ${n} ROWS ONLY`;
+  }
+
+  async createClient(connection: string): Promise<MigrationClient> {
+    const oracledb = interopDefault(await import('oracledb'));
+    const conn = await oracledb.getConnection(parseOracleConnection(connection));
+    const translate = (sql: string) => this.translatePlaceholders(sql);
+    return {
+      dialect: 'oracle',
+      async exec(sql) {
+        await conn.execute(sql, [], { autoCommit: true });
+      },
+      async query(sql, params = []) {
+        const r = await conn.execute<MigrationRow>(translate(sql), params, {
+          outFormat: oracledb.OUT_FORMAT_OBJECT,
+        });
+        return (r.rows ?? []).map(lowercaseKeys);
+      },
+      async run(sql, params = []) {
+        await conn.execute(translate(sql), params, {
+          autoCommit: false,
+        });
+      },
+      async transaction(fn) {
+        try {
+          const r = await fn();
+          await conn.commit();
+          return r;
+        } catch (e) {
+          try {
+            await conn.rollback();
+          } catch (rollbackErr) {
+            console.warn(
+              'oracle rollback failed after transaction error; original error rethrown',
+              rollbackErr,
+            );
+          }
+          throw e;
+        }
+      },
+      async close() {
+        await conn.close();
+      },
+    };
+  }
+}

package/src/dialects/postgres-dialect.test.ts

@@ -0,0 +1,80 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const pg = vi.hoisted(() => {
+  const state = {
+    failRollback: false,
+    ended: false,
+    queries: [] as { sql: string; params?: unknown[] }[],
+  };
+  class Client {
+    constructor(public readonly opts: { connectionString: string }) {}
+    async connect() {}
+    async query(sql: string, params?: unknown[]) {
+      state.queries.push({ sql, params });
+      if (sql === 'ROLLBACK' && state.failRollback) throw new Error('rollback failed');
+      return { rows: [{ n: 1 }] };
+    }
+    async end() {
+      state.ended = true;
+    }
+  }
+  return { Client, state };
+});
+
+vi.mock('pg', () => ({ default: { Client: pg.Client } }));
+
+import { PostgresDialect } from './postgres-dialect.ts';
+
+const dialect = new PostgresDialect();
+
+describe('PostgresDialect', () => {
+  afterEach(() => {
+    pg.state.failRollback = false;
+    pg.state.ended = false;
+    pg.state.queries = [];
+  });
+
+  it('registers as postgres with NOW() and $n placeholders', async () => {
+    expect(dialect.name).toBe('postgres');
+    expect([...dialect.connectionEnvironmentVariables]).toEqual([
+      'PG_CONNECTION_STRING',
+      'DATABASE_URL',
+    ]);
+    expect(dialect.usesLastInsertRowid).toBe(false);
+    expect(dialect.nowExpr()).toBe('NOW()');
+    expect(dialect.translatePlaceholders('WHERE a = ? AND b = ?')).toBe('WHERE a = $1 AND b = $2');
+    expect(dialect.migratesDdl).toMatch(/migrates/i);
+    expect(dialect.migrateLogsDdl).toMatch(/migrate_logs/i);
+    expect(await dialect.prerequisiteError('pg://x')).toBeNull();
+    await dialect.prepareSetup('pg://x');
+  });
+
+  it('createClient talks through pg.Client with translated placeholders', async () => {
+    const client = await dialect.createClient('postgresql://localhost/db');
+    expect(client.dialect).toBe('postgres');
+    await client.exec('SELECT 1');
+    expect(await client.query('SELECT ?', [1])).toEqual([{ n: 1 }]);
+    expect(pg.state.queries.some((q) => q.sql === 'SELECT $1' && q.params?.[0] === 1)).toBe(true);
+    await client.run('UPDATE t SET x = ?', [2]);
+    expect(await client.transaction(async () => 'ok')).toBe('ok');
+    expect(pg.state.queries.map((q) => q.sql)).toContain('BEGIN');
+    expect(pg.state.queries.map((q) => q.sql)).toContain('COMMIT');
+    await expect(
+      client.transaction(async () => {
+        throw new Error('tx');
+      }),
+    ).rejects.toThrow('tx');
+    expect(pg.state.queries.map((q) => q.sql)).toContain('ROLLBACK');
+    pg.state.failRollback = true;
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    await expect(
+      client.transaction(async () => {
+        throw new Error('tx2');
+      }),
+    ).rejects.toThrow('tx2');
+    expect(warn).toHaveBeenCalled();
+    warn.mockRestore();
+    await client.close();
+    expect(pg.state.ended).toBe(true);
+  });
+});

package/src/dialects/postgres-dialect.ts

@@ -0,0 +1,65 @@
+import type { MigrationClient } from '../migration-client.ts';
+import { readSqlTemplate } from '../infrastructure/sql-templates.ts';
+import { SqlDialectBase } from '../abstractions/sql-dialect-base.ts';
+
+const [migratesDdl, migrateLogsDdl] = await Promise.all([
+  readSqlTemplate('postgres', 'migrates'),
+  readSqlTemplate('postgres', 'migrate_logs'),
+]);
+
+export class PostgresDialect extends SqlDialectBase {
+  readonly name = 'postgres' as const;
+  readonly connectionEnvironmentVariables = ['PG_CONNECTION_STRING', 'DATABASE_URL'] as const;
+  readonly migratesDdl = migratesDdl;
+  readonly migrateLogsDdl = migrateLogsDdl;
+
+  nowExpr(): string {
+    return 'NOW()';
+  }
+
+  translatePlaceholders(sql: string): string {
+    let n = 0;
+    return sql.replace(/\?/g, () => `$${++n}`);
+  }
+
+  async createClient(connection: string): Promise<MigrationClient> {
+    const { default: pg } = await import('pg');
+    const client = new pg.Client({ connectionString: connection });
+    await client.connect();
+    const translate = (sql: string) => this.translatePlaceholders(sql);
+    return {
+      dialect: 'postgres',
+      async exec(sql) {
+        await client.query(sql);
+      },
+      async query(sql, params = []) {
+        const r = await client.query(translate(sql), params);
+        return r.rows;
+      },
+      async run(sql, params = []) {
+        await client.query(translate(sql), params);
+      },
+      async transaction(fn) {
+        await client.query('BEGIN');
+        try {
+          const r = await fn();
+          await client.query('COMMIT');
+          return r;
+        } catch (e) {
+          try {
+            await client.query('ROLLBACK');
+          } catch (rollbackErr) {
+            console.warn(
+              'postgres ROLLBACK failed after transaction error; original error rethrown',
+              rollbackErr,
+            );
+          }
+          throw e;
+        }
+      },
+      async close() {
+        await client.end();
+      },
+    };
+  }
+}

package/src/dialects/sqlite-dialect.rollback.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it, vi } from 'vitest';
+
+vi.mock('better-sqlite3', () => ({
+  default: class {
+    exec(sql: string) {
+      if (sql === 'ROLLBACK') throw new Error('rollback failed');
+    }
+    prepare() {
+      return { all() { return []; }, run() {} };
+    }
+    close() {}
+  },
+}));
+
+import { SqliteDialect } from './sqlite-dialect.ts';
+
+describe('SqliteDialect rollback failure', () => {
+  it('warns when ROLLBACK itself fails and still rethrows the original error', async () => {
+    const client = await new SqliteDialect().createClient(':memory:');
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    await expect(
+      client.transaction(async () => {
+        throw new Error('tx');
+      }),
+    ).rejects.toThrow('tx');
+    expect(warn).toHaveBeenCalled();
+    warn.mockRestore();
+    await client.close();
+  });
+});

package/src/dialects/sqlite-dialect.test.ts

@@ -0,0 +1,77 @@
+import { mkdtemp, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { SqliteDialect, sqliteFilesystemPath } from './sqlite-dialect.ts';
+
+const dialect = new SqliteDialect();
+
+describe('SqliteDialect', () => {
+  it('registers as sqlite with SQLITE_PATH / DB_PATH and last_insert_rowid', () => {
+    expect(dialect.name).toBe('sqlite');
+    expect([...dialect.connectionEnvironmentVariables]).toEqual(['SQLITE_PATH', 'DB_PATH']);
+    expect(dialect.usesLastInsertRowid).toBe(true);
+    expect(dialect.migratesDdl).toMatch(/migrates/i);
+    expect(dialect.migrateLogsDdl).toMatch(/migrate_logs/i);
+    expect(dialect.quoteIdent('t')).toBe('"t"');
+    expect(dialect.nowExpr()).toBe('CURRENT_TIMESTAMP');
+    expect(dialect.limitClause(3)).toBe('LIMIT 3');
+    expect(dialect.translatePlaceholders('? ?')).toBe('? ?');
+  });
+
+  it('parses filesystem paths from every supported connection form', () => {
+    expect(sqliteFilesystemPath(':memory:')).toBeNull();
+    expect(sqliteFilesystemPath('')).toBeNull();
+    expect(sqliteFilesystemPath('  :memory:  ')).toBeNull();
+    expect(sqliteFilesystemPath('./app.sqlite')).toBe('./app.sqlite');
+    expect(sqliteFilesystemPath('sqlite:///abs/app.sqlite')).toBe('/abs/app.sqlite');
+    expect(sqliteFilesystemPath('sqlite://rel.sqlite')).toBe('rel.sqlite');
+    expect(sqliteFilesystemPath('sqlite:foo.db')).toBe('foo.db');
+    expect(sqliteFilesystemPath('file:bar.db')).toBe('bar.db');
+    expect(sqliteFilesystemPath('Data Source=./from-ado.sqlite')).toBe('./from-ado.sqlite');
+    expect(sqliteFilesystemPath('data source = /tmp/x.sqlite')).toBe('/tmp/x.sqlite');
+    expect(sqliteFilesystemPath('sqlite://')).toBeNull();
+    expect(sqliteFilesystemPath('file:')).toBeNull();
+    expect(sqliteFilesystemPath('other=value.sqlite')).toBe('other=value.sqlite');
+  });
+
+  it('prerequisiteError is null for memory, existing files, and missing-path-null', async () => {
+    expect(await dialect.prerequisiteError(':memory:')).toBeNull();
+    const dir = await mkdtemp(join(tmpdir(), 'sqlite-dialect-'));
+    const file = join(dir, 'exists.sqlite');
+    await writeFile(file, '');
+    expect(await dialect.prerequisiteError(file)).toBeNull();
+    const missing = join(dir, 'missing.sqlite');
+    const err = await dialect.prerequisiteError(missing);
+    expect(err).toContain(missing);
+    expect(err).toMatch(/migrate-setup --provider sqlite/);
+  });
+
+  it('prepareSetup creates parent directories for file connections and no-ops memory', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'sqlite-setup-'));
+    const file = join(dir, 'nested', 'db', 'app.sqlite');
+    await dialect.prepareSetup(file);
+    const { pathExists } = await import('../path-exists.ts');
+    expect(await pathExists(join(dir, 'nested', 'db'))).toBe(true);
+    await dialect.prepareSetup(':memory:');
+  });
+
+  it('createClient rejects an empty path and runs exec/query/run/transaction on :memory:', async () => {
+    await expect(dialect.createClient('')).rejects.toThrow(/sqlite requires a database file path/);
+    const client = await dialect.createClient(':memory:');
+    expect(client.dialect).toBe('sqlite');
+    await client.exec('CREATE TABLE t (id INTEGER)');
+    await client.run('INSERT INTO t (id) VALUES (?)', [1]);
+    const viaQueryWrite = await client.query('INSERT INTO t (id) VALUES (?)', [2]);
+    expect(viaQueryWrite).toEqual([]);
+    expect(await client.query('SELECT id FROM t ORDER BY id')).toEqual([{ id: 1 }, { id: 2 }]);
+    const tx = await client.transaction(async () => 7);
+    expect(tx).toBe(7);
+    await expect(
+      client.transaction(async () => {
+        throw new Error('boom');
+      }),
+    ).rejects.toThrow('boom');
+    await client.close();
+  });
+});

package/src/dialects/sqlite-dialect.ts

@@ -0,0 +1,96 @@
+import { mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import type { MigrationClient, MigrationRow, MigrationSqlParam } from '../migration-client.ts';
+import { pathExists } from '../path-exists.ts';
+import { readSqlTemplate } from '../infrastructure/sql-templates.ts';
+import { fillTemplate, loadMessage } from '../infrastructure/message-templates.ts';
+import { SqlDialectBase } from '../abstractions/sql-dialect-base.ts';
+
+const [migratesDdl, migrateLogsDdl, sqlitePrerequisiteTpl] = await Promise.all([
+  readSqlTemplate('sqlite', 'migrates'),
+  readSqlTemplate('sqlite', 'migrate_logs'),
+  loadMessage('errors/sqlite-prerequisite'),
+]);
+
+export const sqliteFilesystemPath = (connection: string): string | null => {
+  let s = connection.trim();
+  const eq = s.indexOf('=');
+  if (eq >= 0 && /data\s*source/i.test(s.slice(0, eq))) {
+    s = s.slice(eq + 1).trim();
+  } else if (/^sqlite:\/\//i.test(s)) {
+    s = s.slice('sqlite://'.length);
+  } else if (/^sqlite:/i.test(s)) {
+    s = s.slice('sqlite:'.length);
+  } else if (/^file:/i.test(s)) {
+    s = s.slice('file:'.length);
+  }
+  if (s === ':memory:' || s === '') return null;
+  return s;
+};
+
+export class SqliteDialect extends SqlDialectBase {
+  readonly name = 'sqlite' as const;
+  readonly connectionEnvironmentVariables = ['SQLITE_PATH', 'DB_PATH'] as const;
+  readonly migratesDdl = migratesDdl;
+  readonly migrateLogsDdl = migrateLogsDdl;
+  override readonly usesLastInsertRowid = true;
+
+  async prerequisiteError(connection: string): Promise<string | null> {
+    const path = sqliteFilesystemPath(connection);
+    if (path === null) return null;
+    if (await pathExists(path)) return null;
+    return fillTemplate(sqlitePrerequisiteTpl, { path });
+  }
+
+  async prepareSetup(connection: string): Promise<void> {
+    const filePath = sqliteFilesystemPath(connection);
+    if (filePath !== null) {
+      await mkdir(dirname(filePath), { recursive: true });
+    }
+  }
+
+  async createClient(connection: string): Promise<MigrationClient> {
+    if (!connection) throw new Error('sqlite requires a database file path');
+    const { default: Database } = await import('better-sqlite3');
+    const db = new Database(connection);
+    return {
+      dialect: 'sqlite',
+      async exec(sql) {
+        db.exec(sql);
+      },
+      async query(sql, params = []) {
+        const stmt = db.prepare<MigrationSqlParam[], MigrationRow>(sql);
+        try {
+          return stmt.all(...params);
+        } catch {
+          stmt.run(...params);
+          return [];
+        }
+      },
+      async run(sql, params = []) {
+        db.prepare(sql).run(...params);
+      },
+      async transaction(fn) {
+        db.exec('BEGIN');
+        try {
+          const r = await fn();
+          db.exec('COMMIT');
+          return r;
+        } catch (e) {
+          try {
+            db.exec('ROLLBACK');
+          } catch (rollbackErr) {
+            console.warn(
+              'sqlite ROLLBACK failed after transaction error; original error rethrown',
+              rollbackErr,
+            );
+          }
+          throw e;
+        }
+      },
+      async close() {
+        db.close();
+      },
+    };
+  }
+}

package/src/dialects/sqlserver-dialect.test.ts

@@ -0,0 +1,99 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const mssql = vi.hoisted(() => {
+  const state = {
+    failRollback: false,
+    closed: false,
+    batches: [] as string[],
+    queries: [] as string[],
+    inputs: [] as { name: string; value: unknown }[],
+  };
+  const request = () => ({
+    input(name: string, value: unknown) {
+      state.inputs.push({ name, value });
+    },
+    async query(sql: string) {
+      state.queries.push(sql);
+      if (sql.includes('empty')) return {};
+      return { recordset: [{ n: 1 }] };
+    },
+    async batch(sql: string) {
+      state.batches.push(sql);
+    },
+  });
+  const transaction = () => ({
+    async begin() {},
+    async commit() {},
+    async rollback() {
+      if (state.failRollback) throw new Error('rollback failed');
+    },
+  });
+  const pool = {
+    request,
+    transaction,
+    async close() {
+      state.closed = true;
+    },
+  };
+  return {
+    state,
+    connect: async () => pool,
+  };
+});
+
+vi.mock('mssql', () => ({ default: { connect: mssql.connect } }));
+
+import { SqlServerDialect } from './sqlserver-dialect.ts';
+
+const dialect = new SqlServerDialect();
+
+describe('SqlServerDialect', () => {
+  afterEach(() => {
+    mssql.state.failRollback = false;
+    mssql.state.closed = false;
+    mssql.state.batches = [];
+    mssql.state.queries = [];
+    mssql.state.inputs = [];
+  });
+
+  it('registers as sqlserver with bracket quotes, SYSUTCDATETIME, and OFFSET/FETCH', async () => {
+    expect(dialect.name).toBe('sqlserver');
+    expect([...dialect.connectionEnvironmentVariables]).toEqual(['MSSQL_URL', 'DATABASE_URL']);
+    expect(dialect.quoteIdent('t')).toBe('[t]');
+    expect(dialect.nowExpr()).toBe('SYSUTCDATETIME()');
+    expect(dialect.limitClause(4)).toBe('OFFSET 0 ROWS FETCH NEXT 4 ROWS ONLY');
+    expect(dialect.migratesDdl).toMatch(/migrates/i);
+    expect(dialect.migrateLogsDdl).toMatch(/migrate_logs/i);
+    expect(await dialect.prerequisiteError('mssql://x')).toBeNull();
+    await dialect.prepareSetup('mssql://x');
+  });
+
+  it('createClient binds ? as @pN and handles empty recordsets', async () => {
+    const client = await dialect.createClient('Server=localhost');
+    expect(client.dialect).toBe('sqlserver');
+    await client.exec('CREATE TABLE t (id INT)');
+    expect(mssql.state.batches).toContain('CREATE TABLE t (id INT)');
+    expect(await client.query('SELECT ?', [7])).toEqual([{ n: 1 }]);
+    expect(mssql.state.queries).toContain('SELECT @p0');
+    expect(mssql.state.inputs).toContainEqual({ name: 'p0', value: 7 });
+    expect(await client.query('empty')).toEqual([]);
+    await client.run('UPDATE t SET x = ?', [8]);
+    expect(await client.transaction(async () => 'ok')).toBe('ok');
+    await expect(
+      client.transaction(async () => {
+        throw new Error('tx');
+      }),
+    ).rejects.toThrow('tx');
+    mssql.state.failRollback = true;
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    await expect(
+      client.transaction(async () => {
+        throw new Error('tx2');
+      }),
+    ).rejects.toThrow('tx2');
+    expect(warn).toHaveBeenCalled();
+    warn.mockRestore();
+    await client.close();
+    expect(mssql.state.closed).toBe(true);
+  });
+});