@deterministic-code/migraters 0.0.0-stage → 0.0.2

package/dist/datasource-migrate.js

@@ -0,0 +1,206 @@
+import { createHash } from 'node:crypto';
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { defaultDialectFactory } from "./infrastructure/default-factory.js";
+import { splitOnGo } from "./infrastructure/split-on-go.js";
+import { fillTemplate, loadMessage } from "./infrastructure/message-templates.js";
+export { normalizeDialect } from "./sql.js";
+export { applyMysqlDdlViaTextProtocol } from "./dialects/mysql-dialect.js";
+const UP_SUFFIX = '_up.sql';
+const DOWN_SUFFIX = '_down.sql';
+const [checksumDriftTpl, checksumDriftLineTpl, rollbackNotInPathMsg, rollbackNoSiblingTpl, migratePathNotDirTpl,] = await Promise.all([
+    loadMessage('checksum-drift'),
+    loadMessage('checksum-drift-line'),
+    loadMessage('errors/rollback-not-in-path'),
+    loadMessage('errors/rollback-no-rollback-sibling'),
+    loadMessage('errors/migrate-path-not-dir'),
+]);
+const missingMigrationsDir = (path) => new Error(fillTemplate(migratePathNotDirTpl, { path }).trimEnd());
+export async function discoverMigrations({ migratePath, dialect, }) {
+    requireDialect(dialect);
+    let st;
+    try {
+        st = await stat(migratePath);
+    }
+    catch {
+        throw missingMigrationsDir(migratePath);
+    }
+    if (!st.isDirectory())
+        throw missingMigrationsDir(migratePath);
+    const entries = await readdir(migratePath, { withFileTypes: true });
+    const files = new Set(entries.filter((e) => e.isFile()).map((e) => e.name));
+    const ups = [];
+    for (const name of files) {
+        if (!name.endsWith(UP_SUFFIX))
+            continue;
+        const stem = name.slice(0, -UP_SUFFIX.length);
+        const downName = `${stem}${DOWN_SUFFIX}`;
+        ups.push({
+            name: stem,
+            upPath: join(migratePath, name),
+            downPath: files.has(downName) ? join(migratePath, downName) : null,
+        });
+    }
+    ups.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    return ups;
+}
+/** Strip pre-refactor `-- deterministic-content-hash: <sha>` header if present so upgrading users carrying the legacy header keep the same checksum migrate:up recorded. */
+const LEGACY_HEADER_RE = /^(?:\/\/|--|#)\s+deterministic-content-hash:\s+[0-9a-f]{64}\s*\r?\n?/;
+export function checksum(text) {
+    const body = text.replace(LEGACY_HEADER_RE, '');
+    return createHash('sha256').update(body, 'utf8').digest('hex');
+}
+export async function applyOneUp({ client, migrations, env = process.env, }) {
+    const applied = await appliedRecords(client);
+    await assertNoChecksumDrift({ migrations, applied, env });
+    const next = migrations.find((m) => !applied.has(m.name));
+    if (!next)
+        return { applied: false, name: null };
+    const sqlText = await readFile(next.upPath, 'utf8');
+    const sum = checksum(sqlText);
+    const logId = await insertLogStarted(client, next.name, 'up');
+    const startedAt = Date.now();
+    try {
+        await client.transaction(async () => {
+            const stmts = splitOnGo(await readFile(next.upPath, 'utf8'));
+            for (const stmt of stmts) {
+                await client.exec(stmt);
+            }
+            await insertMigrate(client, next.name, sum);
+        });
+    }
+    catch (e) {
+        const err = e;
+        await updateLogTerminal({
+            client,
+            id: logId,
+            status: 'error',
+            durationMs: Date.now() - startedAt,
+            errorMessage: String(err?.message ?? e),
+        });
+        throw e;
+    }
+    await updateLogTerminal({
+        client,
+        id: logId,
+        status: 'success',
+        durationMs: Date.now() - startedAt,
+        errorMessage: null,
+    });
+    return { applied: true, name: next.name };
+}
+export async function applyOneDown({ client, migrations, env = process.env, }) {
+    const applied = await appliedRecords(client);
+    await assertNoChecksumDrift({ migrations, applied, env });
+    if (applied.size === 0)
+        return { rolledBack: false, name: null };
+    const lastApplied = [...migrations].reverse().find((m) => applied.has(m.name));
+    if (!lastApplied) {
+        throw new Error(rollbackNotInPathMsg.trimEnd());
+    }
+    if (!lastApplied.downPath) {
+        throw new Error(fillTemplate(rollbackNoSiblingTpl, { name: lastApplied.name }).trimEnd());
+    }
+    const downPath = lastApplied.downPath;
+    const logId = await insertLogStarted(client, lastApplied.name, 'down');
+    const startedAt = Date.now();
+    try {
+        await client.transaction(async () => {
+            const stmts = splitOnGo(await readFile(downPath, 'utf8'));
+            for (const stmt of stmts) {
+                await client.exec(stmt);
+            }
+            await deleteMigrate(client, lastApplied.name);
+        });
+    }
+    catch (e) {
+        const err = e;
+        await updateLogTerminal({
+            client,
+            id: logId,
+            status: 'error',
+            durationMs: Date.now() - startedAt,
+            errorMessage: String(err?.message ?? e),
+        });
+        throw e;
+    }
+    await updateLogTerminal({
+        client,
+        id: logId,
+        status: 'success',
+        durationMs: Date.now() - startedAt,
+        errorMessage: null,
+    });
+    return { rolledBack: true, name: lastApplied.name };
+}
+function dialectOf(client) {
+    return defaultDialectFactory.get(client.dialect);
+}
+async function appliedRecords(client) {
+    const d = dialectOf(client);
+    const q = (ident) => d.quoteIdent(ident);
+    const rows = await client.query(`SELECT ${q('name')} AS name, ${q('checksum')} AS checksum FROM ${q('migrates')}`);
+    return new Map(rows.map((r) => [r.name ?? r.NAME, r.checksum ?? r.CHECKSUM ?? null]));
+}
+async function assertNoChecksumDrift({ migrations, applied, env = process.env, }) {
+    if (env.MIGRATE_ALLOW_CHECKSUM_DRIFT === '1')
+        return;
+    const drifted = [];
+    for (const m of migrations) {
+        if (!applied.has(m.name))
+            continue;
+        const stored = applied.get(m.name);
+        if (stored == null)
+            continue;
+        const current = checksum(await readFile(m.upPath, 'utf8'));
+        if (current !== stored)
+            drifted.push({ name: m.name, stored, current });
+    }
+    if (drifted.length === 0)
+        return;
+    const lines = drifted
+        .map((d) => fillTemplate(checksumDriftLineTpl, {
+        name: d.name,
+        stored: d.stored.slice(0, 12),
+        current: d.current.slice(0, 12),
+    }).trimEnd())
+        .join('\n');
+    throw new Error(fillTemplate(checksumDriftTpl, { lines }).trimEnd());
+}
+async function insertMigrate(client, name, sum) {
+    const d = dialectOf(client);
+    const t = d.quoteIdent('migrates');
+    await client.run(`INSERT INTO ${t} (${d.quoteIdent('name')}, ${d.quoteIdent('checksum')}) VALUES (?, ?)`, [name, sum]);
+}
+async function deleteMigrate(client, name) {
+    const d = dialectOf(client);
+    const t = d.quoteIdent('migrates');
+    await client.run(`DELETE FROM ${t} WHERE ${d.quoteIdent('name')} = ?`, [name]);
+}
+async function insertLogStarted(client, name, direction) {
+    const d = dialectOf(client);
+    const t = d.quoteIdent('migrate_logs');
+    if (d.usesLastInsertRowid) {
+        const stmt = `INSERT INTO ${t} (${d.quoteIdent('migrate_name')}, ${d.quoteIdent('direction')}, ${d.quoteIdent('status')}) VALUES (?, ?, 'started')`;
+        const db = client._raw;
+        if (db) {
+            const info = db.prepare(stmt).run(name, direction);
+            return info.lastInsertRowid;
+        }
+        await client.run(stmt, [name, direction]);
+        const rows = await client.query(`SELECT ${d.quoteIdent('id')} AS id FROM ${t} WHERE ${d.quoteIdent('migrate_name')} = ? AND ${d.quoteIdent('direction')} = ? ORDER BY id DESC ${d.limitClause(1)}`, [name, direction]);
+        return rows[0]?.id;
+    }
+    await client.run(`INSERT INTO ${t} (${d.quoteIdent('migrate_name')}, ${d.quoteIdent('direction')}, ${d.quoteIdent('status')}) VALUES (?, ?, 'started')`, [name, direction]);
+    const rows = await client.query(`SELECT ${d.quoteIdent('id')} AS id FROM ${t} WHERE ${d.quoteIdent('migrate_name')} = ? AND ${d.quoteIdent('direction')} = ? ORDER BY ${d.quoteIdent('id')} DESC ${d.limitClause(1)}`, [name, direction]);
+    return rows[0]?.id ?? rows[0]?.ID;
+}
+async function updateLogTerminal({ client, id, status, durationMs, errorMessage, }) {
+    const d = dialectOf(client);
+    const t = d.quoteIdent('migrate_logs');
+    const setNow = d.nowExpr();
+    await client.run(`UPDATE ${t} SET ${d.quoteIdent('status')} = ?, ${d.quoteIdent('finished_at')} = ${setNow}, ${d.quoteIdent('duration_ms')} = ?, ${d.quoteIdent('error_message')} = ?, ${d.quoteIdent('updated')} = ${setNow} WHERE ${d.quoteIdent('id')} = ?`, [status, durationMs, errorMessage, id]);
+}
+function requireDialect(dialect) {
+    return defaultDialectFactory.get(dialect).name;
+}

package/dist/dialects/mysql-dialect.d.ts

@@ -0,0 +1,12 @@
+import type { Connection as MysqlConnection } from 'mysql2/promise';
+import type { MigrationClient } from '../migration-client.ts';
+import { SqlDialectBase } from '../abstractions/sql-dialect-base.ts';
+export declare function applyMysqlDdlViaTextProtocol(conn: Pick<MysqlConnection, 'query'>, sql: string): Promise<void>;
+export declare class MysqlDialect extends SqlDialectBase {
+    readonly name: "mysql";
+    readonly connectionEnvironmentVariables: readonly ["MYSQL_URL", "DATABASE_URL"];
+    readonly migratesDdl: string;
+    readonly migrateLogsDdl: string;
+    quoteIdent(ident: string): string;
+    createClient(connection: string): Promise<MigrationClient>;
+}

package/dist/dialects/mysql-dialect.js

@@ -0,0 +1,56 @@
+import { readSqlTemplate } from "../infrastructure/sql-templates.js";
+import { SqlDialectBase } from "../abstractions/sql-dialect-base.js";
+const [migratesDdl, migrateLogsDdl] = await Promise.all([
+    readSqlTemplate('mysql', 'migrates'),
+    readSqlTemplate('mysql', 'migrate_logs'),
+]);
+export async function applyMysqlDdlViaTextProtocol(conn, sql) {
+    // why: DDL statements (DROP/CREATE PROCEDURE) reject prepared-statement protocol (MySQL 1295)
+    await conn.query(sql);
+}
+export class MysqlDialect extends SqlDialectBase {
+    name = 'mysql';
+    connectionEnvironmentVariables = ['MYSQL_URL', 'DATABASE_URL'];
+    migratesDdl = migratesDdl;
+    migrateLogsDdl = migrateLogsDdl;
+    quoteIdent(ident) {
+        return `\`${ident}\``;
+    }
+    async createClient(connection) {
+        const mysql = await import('mysql2/promise');
+        const conn = await mysql.createConnection(connection);
+        return {
+            dialect: 'mysql',
+            async exec(sql) {
+                await applyMysqlDdlViaTextProtocol(conn, sql);
+            },
+            async query(sql, params = []) {
+                const [rows] = await conn.execute(sql, params);
+                return rows;
+            },
+            async run(sql, params = []) {
+                await conn.execute(sql, params);
+            },
+            async transaction(fn) {
+                await conn.beginTransaction();
+                try {
+                    const r = await fn();
+                    await conn.commit();
+                    return r;
+                }
+                catch (e) {
+                    try {
+                        await conn.rollback();
+                    }
+                    catch (rollbackErr) {
+                        console.warn('mysql rollback failed after transaction error; original error rethrown', rollbackErr);
+                    }
+                    throw e;
+                }
+            },
+            async close() {
+                await conn.end();
+            },
+        };
+    }
+}

package/dist/dialects/oracle-dialect.d.ts

@@ -0,0 +1,18 @@
+import type { MigrationClient } from '../migration-client.ts';
+import { SqlDialectBase } from '../abstractions/sql-dialect-base.ts';
+interface OracleConnectionConfig {
+    user: string;
+    password: string;
+    connectString: string;
+}
+export declare const parseOracleConnection: (connection: string | OracleConnectionConfig) => OracleConnectionConfig;
+export declare class OracleDialect extends SqlDialectBase {
+    readonly name: "oracle";
+    readonly connectionEnvironmentVariables: readonly ["ORACLE_CONNECT_STRING", "DATABASE_URL"];
+    readonly migratesDdl: string;
+    readonly migrateLogsDdl: string;
+    translatePlaceholders(sql: string): string;
+    limitClause(n: number): string;
+    createClient(connection: string): Promise<MigrationClient>;
+}
+export {};

package/dist/dialects/oracle-dialect.js

@@ -0,0 +1,76 @@
+import { interopDefault } from "../infrastructure/interop-default.js";
+import { readSqlTemplate } from "../infrastructure/sql-templates.js";
+import { SqlDialectBase } from "../abstractions/sql-dialect-base.js";
+const [migratesDdl, migrateLogsDdl] = await Promise.all([
+    readSqlTemplate('oracle', 'migrates'),
+    readSqlTemplate('oracle', 'migrate_logs'),
+]);
+export const parseOracleConnection = (connection) => {
+    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], password: m[2], connectString: m[3] };
+};
+const lowercaseKeys = (row) => {
+    const out = {};
+    for (const [k, v] of Object.entries(row))
+        out[k.toLowerCase()] = v;
+    return out;
+};
+export class OracleDialect extends SqlDialectBase {
+    name = 'oracle';
+    connectionEnvironmentVariables = ['ORACLE_CONNECT_STRING', 'DATABASE_URL'];
+    migratesDdl = migratesDdl;
+    migrateLogsDdl = migrateLogsDdl;
+    translatePlaceholders(sql) {
+        let n = 0;
+        return sql.replace(/\?/g, () => `:${++n}`);
+    }
+    limitClause(n) {
+        return `FETCH FIRST ${n} ROWS ONLY`;
+    }
+    async createClient(connection) {
+        const oracledb = interopDefault(await import('oracledb'));
+        const conn = await oracledb.getConnection(parseOracleConnection(connection));
+        const translate = (sql) => this.translatePlaceholders(sql);
+        return {
+            dialect: 'oracle',
+            async exec(sql) {
+                await conn.execute(sql, [], { autoCommit: true });
+            },
+            async query(sql, params = []) {
+                const r = await conn.execute(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/dist/dialects/postgres-dialect.d.ts

@@ -0,0 +1,11 @@
+import type { MigrationClient } from '../migration-client.ts';
+import { SqlDialectBase } from '../abstractions/sql-dialect-base.ts';
+export declare class PostgresDialect extends SqlDialectBase {
+    readonly name: "postgres";
+    readonly connectionEnvironmentVariables: readonly ["PG_CONNECTION_STRING", "DATABASE_URL"];
+    readonly migratesDdl: string;
+    readonly migrateLogsDdl: string;
+    nowExpr(): string;
+    translatePlaceholders(sql: string): string;
+    createClient(connection: string): Promise<MigrationClient>;
+}

package/dist/dialects/postgres-dialect.js

@@ -0,0 +1,58 @@
+import { readSqlTemplate } from "../infrastructure/sql-templates.js";
+import { SqlDialectBase } from "../abstractions/sql-dialect-base.js";
+const [migratesDdl, migrateLogsDdl] = await Promise.all([
+    readSqlTemplate('postgres', 'migrates'),
+    readSqlTemplate('postgres', 'migrate_logs'),
+]);
+export class PostgresDialect extends SqlDialectBase {
+    name = 'postgres';
+    connectionEnvironmentVariables = ['PG_CONNECTION_STRING', 'DATABASE_URL'];
+    migratesDdl = migratesDdl;
+    migrateLogsDdl = migrateLogsDdl;
+    nowExpr() {
+        return 'NOW()';
+    }
+    translatePlaceholders(sql) {
+        let n = 0;
+        return sql.replace(/\?/g, () => `$${++n}`);
+    }
+    async createClient(connection) {
+        const { default: pg } = await import('pg');
+        const client = new pg.Client({ connectionString: connection });
+        await client.connect();
+        const translate = (sql) => 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/dist/dialects/sqlite-dialect.d.ts

@@ -0,0 +1,13 @@
+import type { MigrationClient } from '../migration-client.ts';
+import { SqlDialectBase } from '../abstractions/sql-dialect-base.ts';
+export declare const sqliteFilesystemPath: (connection: string) => string | null;
+export declare class SqliteDialect extends SqlDialectBase {
+    readonly name: "sqlite";
+    readonly connectionEnvironmentVariables: readonly ["SQLITE_PATH", "DB_PATH"];
+    readonly migratesDdl: string;
+    readonly migrateLogsDdl: string;
+    readonly usesLastInsertRowid = true;
+    prerequisiteError(connection: string): Promise<string | null>;
+    prepareSetup(connection: string): Promise<void>;
+    createClient(connection: string): Promise<MigrationClient>;
+}

package/dist/dialects/sqlite-dialect.js

@@ -0,0 +1,96 @@
+import { mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { pathExists } from "../path-exists.js";
+import { readSqlTemplate } from "../infrastructure/sql-templates.js";
+import { fillTemplate, loadMessage } from "../infrastructure/message-templates.js";
+import { SqlDialectBase } from "../abstractions/sql-dialect-base.js";
+const [migratesDdl, migrateLogsDdl, sqlitePrerequisiteTpl] = await Promise.all([
+    readSqlTemplate('sqlite', 'migrates'),
+    readSqlTemplate('sqlite', 'migrate_logs'),
+    loadMessage('errors/sqlite-prerequisite'),
+]);
+export const sqliteFilesystemPath = (connection) => {
+    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 {
+    name = 'sqlite';
+    connectionEnvironmentVariables = ['SQLITE_PATH', 'DB_PATH'];
+    migratesDdl = migratesDdl;
+    migrateLogsDdl = migrateLogsDdl;
+    usesLastInsertRowid = true;
+    async prerequisiteError(connection) {
+        const path = sqliteFilesystemPath(connection);
+        if (path === null)
+            return null;
+        if (await pathExists(path))
+            return null;
+        return fillTemplate(sqlitePrerequisiteTpl, { path });
+    }
+    async prepareSetup(connection) {
+        const filePath = sqliteFilesystemPath(connection);
+        if (filePath !== null) {
+            await mkdir(dirname(filePath), { recursive: true });
+        }
+    }
+    async createClient(connection) {
+        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(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/dist/dialects/sqlserver-dialect.d.ts

@@ -0,0 +1,12 @@
+import type { MigrationClient } from '../migration-client.ts';
+import { SqlDialectBase } from '../abstractions/sql-dialect-base.ts';
+export declare class SqlServerDialect extends SqlDialectBase {
+    readonly name: "sqlserver";
+    readonly connectionEnvironmentVariables: readonly ["MSSQL_URL", "DATABASE_URL"];
+    readonly migratesDdl: string;
+    readonly migrateLogsDdl: string;
+    quoteIdent(ident: string): string;
+    nowExpr(): string;
+    limitClause(n: number): string;
+    createClient(connection: string): Promise<MigrationClient>;
+}

package/dist/dialects/sqlserver-dialect.js

@@ -0,0 +1,73 @@
+import { interopDefault } from "../infrastructure/interop-default.js";
+import { readSqlTemplate } from "../infrastructure/sql-templates.js";
+import { SqlDialectBase } from "../abstractions/sql-dialect-base.js";
+const [migratesDdl, migrateLogsDdl] = await Promise.all([
+    readSqlTemplate('sqlserver', 'migrates'),
+    readSqlTemplate('sqlserver', 'migrate_logs'),
+]);
+const bindMssql = (req, sql, params) => {
+    let n = 0;
+    return sql.replace(/\?/g, () => {
+        const name = `p${n}`;
+        req.input(name, params[n]);
+        n++;
+        return `@${name}`;
+    });
+};
+export class SqlServerDialect extends SqlDialectBase {
+    name = 'sqlserver';
+    connectionEnvironmentVariables = ['MSSQL_URL', 'DATABASE_URL'];
+    migratesDdl = migratesDdl;
+    migrateLogsDdl = migrateLogsDdl;
+    quoteIdent(ident) {
+        return `[${ident}]`;
+    }
+    nowExpr() {
+        return 'SYSUTCDATETIME()';
+    }
+    limitClause(n) {
+        return `OFFSET 0 ROWS FETCH NEXT ${n} ROWS ONLY`;
+    }
+    async createClient(connection) {
+        const mssql = interopDefault(await import('mssql'));
+        const pool = await mssql.connect(connection);
+        return {
+            dialect: 'sqlserver',
+            async exec(sql) {
+                await pool.request().batch(sql);
+            },
+            async query(sql, params = []) {
+                const req = pool.request();
+                const translated = bindMssql(req, sql, params);
+                const r = await req.query(translated);
+                return r.recordset ?? [];
+            },
+            async run(sql, params = []) {
+                const req = pool.request();
+                const translated = bindMssql(req, sql, params);
+                await req.query(translated);
+            },
+            async transaction(fn) {
+                const tx = pool.transaction();
+                await tx.begin();
+                try {
+                    const r = await fn();
+                    await tx.commit();
+                    return r;
+                }
+                catch (e) {
+                    try {
+                        await tx.rollback();
+                    }
+                    catch (rollbackErr) {
+                        console.warn('sqlserver rollback failed after transaction error; original error rethrown', rollbackErr);
+                    }
+                    throw e;
+                }
+            },
+            async close() {
+                await pool.close();
+            },
+        };
+    }
+}

package/dist/help.d.ts

@@ -0,0 +1,2 @@
+export declare const loadHelp: (command: string) => Promise<string>;
+export declare const loadProgramUsage: () => Promise<string>;

package/dist/help.js

@@ -0,0 +1,10 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fillHelpTemplate, programUsageText, verbFromCommand } from "./cli-contract.js";
+import { templatesRoot } from "./infrastructure/templates-root.js";
+export const loadHelp = async (command) => {
+    const verb = verbFromCommand(command);
+    const text = await readFile(join(templatesRoot(), 'help', `${verb}.txt`), 'utf8');
+    return fillHelpTemplate(text, command);
+};
+export const loadProgramUsage = async () => programUsageText();

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './datasource-migrate.ts';
+export type { CreateArg, CreateResponse, DownArg, IMigrater, SetupArg, UpArg, } from './abstractions/migrater.ts';
+export { getMigrater, Migrater } from './migrater.ts';
+export { fillHelpTemplate, migrateCommand, verbFromCommand, type MigrateVerb, } from './cli-contract.ts';
+export { loadHelp, loadProgramUsage } from './help.ts';
+export { fillTemplate, loadMessage, loadScaffold, } from './infrastructure/message-templates.ts';
+export { normalizeDialect, pathExists, type SqlDialect } from './sql.ts';

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./datasource-migrate.js";
+export { getMigrater, Migrater } from "./migrater.js";
+export { fillHelpTemplate, migrateCommand, verbFromCommand, } from "./cli-contract.js";
+export { loadHelp, loadProgramUsage } from "./help.js";
+export { fillTemplate, loadMessage, loadScaffold, } from "./infrastructure/message-templates.js";
+export { normalizeDialect, pathExists } from "./sql.js";