@deterministic-code/migraters 0.0.1 → 0.0.3

package/dist/datasource-migrate.js

@@ -1,206 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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.js

@@ -1,10 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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";

package/dist/infrastructure/connection-resolver.d.ts

@@ -1,7 +0,0 @@
-import type { ISqlDialect } from '../abstractions/sql-dialect.ts';
-export declare class ConnectionResolver {
-    private readonly env;
-    constructor(env?: NodeJS.ProcessEnv);
-    fromEnvironment(dialect: ISqlDialect): string | null;
-    resolve(dialect: ISqlDialect, fromFlag: string | null): string | null;
-}