@deterministic-code/migraters 0.0.4 → 0.0.6

package/typescript/{dialects/oracle/src/oracle-dialect.ts → providers/oracle/src/oracle-provider.ts}

@@ -1,37 +1,24 @@
+import type { IDatasourceProvider, ProviderLogId } from '../../../src/abstractions/datasource-provider.ts';
 import type { MigrationClient, MigrationRow } from '../../../src/migration-client.ts';
 import { interopDefault } from '../../../src/infrastructure/interop-default.ts';
 import { readSqlTemplate } from '../../../src/infrastructure/sql-templates.ts';
-import { SqlDialectBase } from '../../../src/abstractions/sql-dialect-base.ts';
+import { parseOracleConnection } from '../../sql/connection-normalizer.ts';
+import { sqlRun } from '../../sql/sql-run.ts';
+
+export { parseOracleConnection };
 
 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 {
+export class OracleProvider implements IDatasourceProvider {
   readonly name = 'oracle' as const;
   readonly connectionEnvironmentVariables = ['ORACLE_CONNECT_STRING', 'DATABASE_URL'] as const;
   readonly migratesDdl = migratesDdl;
@@ -42,10 +29,22 @@ export class OracleDialect extends SqlDialectBase {
     return sql.replace(/\?/g, () => `:${++n}`);
   }
 
+  quoteIdent(ident: string): string {
+    return `"${ident}"`;
+  }
+
   limitClause(n: number): string {
     return `FETCH FIRST ${n} ROWS ONLY`;
   }
 
+  async prerequisiteError(_connection: string): Promise<string | null> {
+    return null;
+  }
+
+  async prepareSetup(_connection: string): Promise<void> {}
+
+  async createDatabaseIfMissing(_connection: string): Promise<void> {}
+
   async createClient(connection: string): Promise<MigrationClient> {
     const oracledb = interopDefault(await import('oracledb'));
     const conn = await oracledb.getConnection(parseOracleConnection(connection));
@@ -88,4 +87,32 @@ export class OracleDialect extends SqlDialectBase {
       },
     };
   }
+
+  setup(connection: string): Promise<void> {
+    return sqlRun.setup(this, connection);
+  }
+
+  applied(connection: string): Promise<Map<string, string | null>> {
+    return sqlRun.applied(this, connection);
+  }
+
+  migrateUp(connection: string, name: string, body: string, checksum: string): Promise<void> {
+    return sqlRun.migrateUp(this, connection, name, body, checksum);
+  }
+
+  migrateDown(connection: string, name: string, body: string): Promise<void> {
+    return sqlRun.migrateDown(this, connection, name, body);
+  }
+
+  log(
+    connection: string,
+    id: ProviderLogId | null,
+    name: string,
+    direction: string,
+    status: string | null,
+    durationMs: number,
+    error: string | null,
+  ): Promise<ProviderLogId> {
+    return sqlRun.log(this, connection, id, name, direction, status, durationMs, error);
+  }
 }

package/typescript/providers/postgres/src/index.ts

@@ -0,0 +1,5 @@
+import { PostgresProvider } from './postgres-provider.ts';
+
+export const createProvider = (): PostgresProvider => new PostgresProvider();
+export const provider = createProvider;
+export { PostgresProvider };

package/typescript/{dialects/postgres/src/postgres-dialect.test.ts → providers/postgres/src/postgres-provider.test.ts}

@@ -27,11 +27,11 @@ const pg = vi.hoisted(() => {
 
 vi.mock('pg', () => ({ default: { Client: pg.Client } }));
 
-import { PostgresDialect } from './postgres-dialect.ts';
+import { PostgresProvider } from './postgres-provider.ts';
 
-const dialect = new PostgresDialect();
+const dialect = new PostgresProvider();
 
-describe('PostgresDialect', () => {
+describe('PostgresProvider', () => {
   afterEach(() => {
     pg.state.failRollback = false;
     pg.state.fail = false;
@@ -95,4 +95,14 @@ describe('PostgresDialect', () => {
     await client.close();
     expect(pg.state.ended).toBe(true);
   });
+
+  it('runs setup, applied, migrate, and log through the sql helper', async () => {
+    const url = 'postgresql://localhost/db';
+    await dialect.setup(url);
+    expect(await dialect.applied(url)).toBeInstanceOf(Map);
+    await dialect.migrateUp(url, 'a', 'SELECT 1', 'sum');
+    await dialect.migrateDown(url, 'a', 'SELECT 1');
+    await dialect.log(url, null, 'a', 'up', null, 0, null);
+    await dialect.log(url, 1, 'a', 'up', 'ok', 1, null);
+  });
 });

package/typescript/{dialects/postgres/src/postgres-dialect.ts → providers/postgres/src/postgres-provider.ts}

@@ -1,17 +1,19 @@
+import type { IDatasourceProvider, ProviderLogId } from '../../../src/abstractions/datasource-provider.ts';
 import type { MigrationClient } from '../../../src/migration-client.ts';
 import { readSqlTemplate } from '../../../src/infrastructure/sql-templates.ts';
-import { SqlDialectBase } from '../../../src/abstractions/sql-dialect-base.ts';
+import { sqlRun } from '../../sql/sql-run.ts';
 
 const [migratesDdl, migrateLogsDdl] = await Promise.all([
   readSqlTemplate('postgres', 'migrates'),
   readSqlTemplate('postgres', 'migrate_logs'),
 ]);
 
-export class PostgresDialect extends SqlDialectBase {
+export class PostgresProvider implements IDatasourceProvider {
   readonly name = 'postgres' as const;
   readonly connectionEnvironmentVariables = ['PG_CONNECTION_STRING', 'DATABASE_URL'] as const;
   readonly migratesDdl = migratesDdl;
   readonly migrateLogsDdl = migrateLogsDdl;
+  readonly usesLastInsertRowid = false;
 
   nowExpr(): string {
     return 'NOW()';
@@ -22,6 +24,12 @@ export class PostgresDialect extends SqlDialectBase {
     return sql.replace(/\?/g, () => `$${++n}`);
   }
 
+  async prerequisiteError(_connection: string): Promise<string | null> {
+    return null;
+  }
+
+  async prepareSetup(_connection: string): Promise<void> {}
+
   async createDatabaseIfMissing(connection: string): Promise<void> {
     const url = new URL(connection);
     const name = url.pathname.replace(/^\//, '');
@@ -79,4 +87,32 @@ export class PostgresDialect extends SqlDialectBase {
       },
     };
   }
+
+  setup(connection: string): Promise<void> {
+    return sqlRun.setup(this, connection);
+  }
+
+  applied(connection: string): Promise<Map<string, string | null>> {
+    return sqlRun.applied(this, connection);
+  }
+
+  migrateUp(connection: string, name: string, body: string, checksum: string): Promise<void> {
+    return sqlRun.migrateUp(this, connection, name, body, checksum);
+  }
+
+  migrateDown(connection: string, name: string, body: string): Promise<void> {
+    return sqlRun.migrateDown(this, connection, name, body);
+  }
+
+  log(
+    connection: string,
+    id: ProviderLogId | null,
+    name: string,
+    direction: string,
+    status: string | null,
+    durationMs: number,
+    error: string | null,
+  ): Promise<ProviderLogId> {
+    return sqlRun.log(this, connection, id, name, direction, status, durationMs, error);
+  }
 }

package/typescript/providers/sql/connection-normalizer.ts

@@ -0,0 +1,48 @@
+export const sqliteIsMemory = (connection: string): boolean => {
+  const s = connection.trim();
+  if (s === '' || s === ':memory:') return true;
+  const compact = s.toLowerCase().replace(/\s+/g, '');
+  return (
+    compact.includes(':memory:') ||
+    /[?&;]mode=memory(?:&|;|$)/.test(compact) ||
+    compact.startsWith('mode=memory')
+  );
+};
+
+export const sqliteFilesystemPath = (connection: string): string | null => {
+  if (sqliteIsMemory(connection)) return 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();
+    const semi = s.indexOf(';');
+    if (semi >= 0) s = s.slice(0, semi).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);
+  }
+  const q = s.indexOf('?');
+  if (q >= 0) s = s.slice(0, q);
+  if (s === ':memory:' || s === '') return null;
+  return s;
+};
+
+export type 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 };
+};

package/typescript/providers/sql/sql-run.ts

@@ -0,0 +1,153 @@
+import type { ProviderLogId } from '../../src/abstractions/datasource-provider.ts';
+import type { MigrationClient, MigrationRowValue } from '../../src/migration-client.ts';
+import { splitOnGo } from './split-on-go.ts';
+
+const catalogName = (stored: string): string =>
+  stored.endsWith('_up.sql') ? stored.slice(0, -'_up.sql'.length) : stored;
+
+export type SqlRunSurface = {
+  migratesDdl: string;
+  migrateLogsDdl: string;
+  usesLastInsertRowid?: boolean;
+  quoteIdent?: (ident: string) => string;
+  nowExpr?: () => string;
+  limitClause?: (n: number) => string;
+  prerequisiteError?: (connection: string) => Promise<string | null>;
+  createClient: (connection: string) => Promise<MigrationClient>;
+};
+
+const quoteIdent = (surface: SqlRunSurface, ident: string): string =>
+  surface.quoteIdent?.(ident) ?? `"${ident}"`;
+
+const nowExpr = (surface: SqlRunSurface): string => surface.nowExpr?.() ?? 'CURRENT_TIMESTAMP';
+
+const limitClause = (surface: SqlRunSurface, n: number): string =>
+  surface.limitClause?.(n) ?? `LIMIT ${n}`;
+
+const openExisting = async (surface: SqlRunSurface, connection: string): Promise<MigrationClient> => {
+  const error = (await surface.prerequisiteError?.(connection)) ?? null;
+  if (error) throw new Error(error);
+  return surface.createClient(connection);
+};
+
+export const sqlRun = {
+  async setup(surface: SqlRunSurface, connection: string): Promise<void> {
+    const client = await surface.createClient(connection);
+    try {
+      await client.exec(surface.migratesDdl);
+      await client.exec(surface.migrateLogsDdl);
+    } finally {
+      await client.close();
+    }
+  },
+
+  async applied(surface: SqlRunSurface, connection: string): Promise<Map<string, string | null>> {
+    const client = await openExisting(surface, connection);
+    try {
+      const q = (ident: string) => quoteIdent(surface, ident);
+      const rows = await client.query(
+        `SELECT ${q('name')} AS name, ${q('checksum')} AS checksum FROM ${q('migrates')}`,
+      );
+      return new Map(
+        rows.map(
+          (r) =>
+            [
+              catalogName(String(r.name ?? r.NAME ?? '')),
+              (r.checksum ?? r.CHECKSUM ?? null) as string | null,
+            ] as [string, string | null],
+        ),
+      );
+    } finally {
+      await client.close();
+    }
+  },
+
+  async migrateUp(
+    surface: SqlRunSurface,
+    connection: string,
+    name: string,
+    body: string,
+    checksum: string,
+  ): Promise<void> {
+    const client = await openExisting(surface, connection);
+    try {
+      const q = (ident: string) => quoteIdent(surface, ident);
+      await client.transaction(async () => {
+        for (const stmt of splitOnGo(body)) {
+          await client.exec(stmt);
+        }
+        const t = q('migrates');
+        await client.run(`INSERT INTO ${t} (${q('name')}, ${q('checksum')}) VALUES (?, ?)`, [
+          name,
+          checksum,
+        ]);
+      });
+    } finally {
+      await client.close();
+    }
+  },
+
+  async migrateDown(
+    surface: SqlRunSurface,
+    connection: string,
+    name: string,
+    body: string,
+  ): Promise<void> {
+    const client = await openExisting(surface, connection);
+    try {
+      const q = (ident: string) => quoteIdent(surface, ident);
+      await client.transaction(async () => {
+        for (const stmt of splitOnGo(body)) {
+          await client.exec(stmt);
+        }
+        const t = q('migrates');
+        await client.run(`DELETE FROM ${t} WHERE ${q('name')} = ?`, [name]);
+      });
+    } finally {
+      await client.close();
+    }
+  },
+
+  async log(
+    surface: SqlRunSurface,
+    connection: string,
+    id: ProviderLogId | null,
+    name: string,
+    direction: string,
+    status: string | null,
+    durationMs: number,
+    error: string | null,
+  ): Promise<ProviderLogId> {
+    const client = await surface.createClient(connection);
+    try {
+      const q = (ident: string) => quoteIdent(surface, ident);
+      const t = q('migrate_logs');
+      if (id == null) {
+        if (surface.usesLastInsertRowid) {
+          const stmt = `INSERT INTO ${t} (${q('migrate_name')}, ${q('direction')}, ${q('status')}) VALUES (?, ?, 'started')`;
+          const db = client._raw;
+          if (db) return db.prepare(stmt).run(name, direction).lastInsertRowid;
+          await client.run(stmt, [name, direction]);
+        } else {
+          await client.run(
+            `INSERT INTO ${t} (${q('migrate_name')}, ${q('direction')}, ${q('status')}) VALUES (?, ?, 'started')`,
+            [name, direction],
+          );
+        }
+        const rows = await client.query(
+          `SELECT ${q('id')} AS id FROM ${t} WHERE ${q('migrate_name')} = ? AND ${q('direction')} = ? ORDER BY ${q('id')} DESC ${limitClause(surface, 1)}`,
+          [name, direction],
+        );
+        return (rows[0]?.id ?? rows[0]?.ID) as MigrationRowValue as ProviderLogId;
+      }
+      const setNow = nowExpr(surface);
+      await client.run(
+        `UPDATE ${t} SET ${q('status')} = ?, ${q('finished_at')} = ${setNow}, ${q('duration_ms')} = ?, ${q('error_message')} = ?, ${q('updated')} = ${setNow} WHERE ${q('id')} = ?`,
+        [status, durationMs, error, id],
+      );
+      return id;
+    } finally {
+      await client.close();
+    }
+  },
+};

package/typescript/providers/sqlite/src/index.ts

@@ -0,0 +1,5 @@
+import { SqliteProvider } from './sqlite-provider.ts';
+
+export const createProvider = (): SqliteProvider => new SqliteProvider();
+export const provider = createProvider;
+export { SqliteProvider, sqliteFilesystemPath } from './sqlite-provider.ts';

package/typescript/providers/sqlite/src/sqlite-provider.paths.test.ts

@@ -0,0 +1,28 @@
+import { mkdtemp, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { SqliteProvider } from './sqlite-provider.ts';
+
+const dialect = new SqliteProvider();
+
+describe('SqliteProvider file paths', () => {
+  it('prerequisiteError is null for existing files and reports missing files', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'sqlite-provider-'));
+    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', 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('../../../src/path-exists.ts');
+    expect(await pathExists(join(dir, 'nested', 'db'))).toBe(true);
+  });
+});

package/typescript/{dialects/sqlite/src/sqlite-dialect.rollback.test.ts → providers/sqlite/src/sqlite-provider.rollback.test.ts}

@@ -12,11 +12,11 @@ vi.mock('better-sqlite3', () => ({
   },
 }));
 
-import { SqliteDialect } from './sqlite-dialect.ts';
+import { SqliteProvider } from './sqlite-provider.ts';
 
-describe('SqliteDialect rollback failure', () => {
+describe('SqliteProvider rollback failure', () => {
   it('warns when ROLLBACK itself fails and still rethrows the original error', async () => {
-    const client = await new SqliteDialect().createClient(':memory:');
+    const client = await new SqliteProvider().createClient(':memory:');
     const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
     await expect(
       client.transaction(async () => {

package/typescript/{dialects/sqlite/src/sqlite-dialect.test.ts → providers/sqlite/src/sqlite-provider.test.ts}

@@ -1,12 +1,9 @@
-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';
+import { SqliteProvider, sqliteFilesystemPath } from './sqlite-provider.ts';
 
-const dialect = new SqliteDialect();
+const dialect = new SqliteProvider();
 
-describe('SqliteDialect', () => {
+describe('SqliteProvider', () => {
   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']);
@@ -23,6 +20,8 @@ describe('SqliteDialect', () => {
     expect(sqliteFilesystemPath(':memory:')).toBeNull();
     expect(sqliteFilesystemPath('')).toBeNull();
     expect(sqliteFilesystemPath('  :memory:  ')).toBeNull();
+    expect(sqliteFilesystemPath('file:migraters-test?mode=memory&cache=shared')).toBeNull();
+    expect(sqliteFilesystemPath('Data Source=migraters-test;Mode=Memory;Cache=Shared')).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');
@@ -35,25 +34,14 @@ describe('SqliteDialect', () => {
     expect(sqliteFilesystemPath('other=value.sqlite')).toBe('other=value.sqlite');
   });
 
-  it('prerequisiteError is null for memory, existing files, and missing-path-null', async () => {
+  it('prerequisiteError is null for memory connections', 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('../../../src/path-exists.ts');
-    expect(await pathExists(join(dir, 'nested', 'db'))).toBe(true);
+    expect(await dialect.prerequisiteError('file:migraters-test?mode=memory&cache=shared')).toBeNull();
+    expect(
+      await dialect.prerequisiteError('Data Source=migraters-test;Mode=Memory;Cache=Shared'),
+    ).toBeNull();
     await dialect.prepareSetup(':memory:');
+    await dialect.prepareSetup('file:migraters-test?mode=memory&cache=shared');
   });
 
   it('createClient rejects an empty path and runs exec/query/run/transaction on :memory:', async () => {

package/typescript/{dialects/sqlite/src/sqlite-dialect.ts → providers/sqlite/src/sqlite-provider.ts}

@@ -1,10 +1,14 @@
 import { mkdir } from 'node:fs/promises';
 import { dirname } from 'node:path';
+import type { IDatasourceProvider, ProviderLogId } from '../../../src/abstractions/datasource-provider.ts';
 import type { MigrationClient, MigrationRow, MigrationSqlParam } from '../../../src/migration-client.ts';
 import { pathExists } from '../../../src/path-exists.ts';
 import { readSqlTemplate } from '../../../src/infrastructure/sql-templates.ts';
 import { fillTemplate, loadMessage } from '../../../src/infrastructure/message-templates.ts';
-import { SqlDialectBase } from '../../../src/abstractions/sql-dialect-base.ts';
+import { sqliteFilesystemPath } from '../../sql/connection-normalizer.ts';
+import { sqlRun } from '../../sql/sql-run.ts';
+
+export { sqliteFilesystemPath };
 
 const [migratesDdl, migrateLogsDdl, sqlitePrerequisiteTpl] = await Promise.all([
   readSqlTemplate('sqlite', 'migrates'),
@@ -12,28 +16,28 @@ const [migratesDdl, migrateLogsDdl, sqlitePrerequisiteTpl] = await Promise.all([
   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 {
+export class SqliteProvider implements IDatasourceProvider {
   readonly name = 'sqlite' as const;
   readonly connectionEnvironmentVariables = ['SQLITE_PATH', 'DB_PATH'] as const;
   readonly migratesDdl = migratesDdl;
   readonly migrateLogsDdl = migrateLogsDdl;
-  override readonly usesLastInsertRowid = true;
+  readonly usesLastInsertRowid = true;
+
+  quoteIdent(ident: string): string {
+    return `"${ident}"`;
+  }
+
+  nowExpr(): string {
+    return 'CURRENT_TIMESTAMP';
+  }
+
+  limitClause(n: number): string {
+    return `LIMIT ${n}`;
+  }
+
+  translatePlaceholders(sql: string): string {
+    return sql;
+  }
 
   async prerequisiteError(connection: string): Promise<string | null> {
     const path = sqliteFilesystemPath(connection);
@@ -49,6 +53,8 @@ export class SqliteDialect extends SqlDialectBase {
     }
   }
 
+  async createDatabaseIfMissing(_connection: string): Promise<void> {}
+
   async createClient(connection: string): Promise<MigrationClient> {
     if (!connection) throw new Error('sqlite requires a database file path');
     const { default: Database } = await import('better-sqlite3');
@@ -93,4 +99,32 @@ export class SqliteDialect extends SqlDialectBase {
       },
     };
   }
+
+  setup(connection: string): Promise<void> {
+    return sqlRun.setup(this, connection);
+  }
+
+  applied(connection: string): Promise<Map<string, string | null>> {
+    return sqlRun.applied(this, connection);
+  }
+
+  migrateUp(connection: string, name: string, body: string, checksum: string): Promise<void> {
+    return sqlRun.migrateUp(this, connection, name, body, checksum);
+  }
+
+  migrateDown(connection: string, name: string, body: string): Promise<void> {
+    return sqlRun.migrateDown(this, connection, name, body);
+  }
+
+  log(
+    connection: string,
+    id: ProviderLogId | null,
+    name: string,
+    direction: string,
+    status: string | null,
+    durationMs: number,
+    error: string | null,
+  ): Promise<ProviderLogId> {
+    return sqlRun.log(this, connection, id, name, direction, status, durationMs, error);
+  }
 }

package/typescript/providers/sqlserver/src/index.ts

@@ -0,0 +1,5 @@
+import { SqlServerProvider } from './sqlserver-provider.ts';
+
+export const createProvider = (): SqlServerProvider => new SqlServerProvider();
+export const provider = createProvider;
+export { SqlServerProvider };

package/typescript/{dialects/sqlserver/src/sqlserver-dialect.test.ts → providers/sqlserver/src/sqlserver-provider.test.ts}

@@ -43,11 +43,11 @@ const mssql = vi.hoisted(() => {
 
 vi.mock('mssql', () => ({ default: { connect: mssql.connect } }));
 
-import { SqlServerDialect } from './sqlserver-dialect.ts';
+import { SqlServerProvider } from './sqlserver-provider.ts';
 
-const dialect = new SqlServerDialect();
+const dialect = new SqlServerProvider();
 
-describe('SqlServerDialect', () => {
+describe('SqlServerProvider', () => {
   afterEach(() => {
     mssql.state.failRollback = false;
     mssql.state.closed = false;
@@ -106,4 +106,14 @@ describe('SqlServerDialect', () => {
     await client.close();
     expect(mssql.state.closed).toBe(true);
   });
+
+  it('runs setup, applied, migrate, and log through the sql helper', async () => {
+    const url = 'Server=localhost';
+    await dialect.setup(url);
+    expect(await dialect.applied(url)).toBeInstanceOf(Map);
+    await dialect.migrateUp(url, 'a', 'SELECT 1', 'sum');
+    await dialect.migrateDown(url, 'a', 'SELECT 1');
+    await dialect.log(url, null, 'a', 'up', null, 0, null);
+    await dialect.log(url, 1, 'a', 'up', 'ok', 1, null);
+  });
 });