@deterministic-code/migraters 0.0.2 → 0.0.3

package/dist/bin/migrate-up.js

@@ -1,97 +0,0 @@
-#!/usr/bin/env node
-// Default: applies ALL pending migrations in sequence, each in its own transaction. Pass --one to apply only the next pending migration (legacy one-shot behavior; useful when wrapping in an external loop or when you want to inspect state between steps).
-import { resolve } from 'node:path';
-import { missingProviderMsg, requireConnection, requireDialect, takeFlag } from "../cli.js";
-import { fillTemplate, loadMessage } from "../infrastructure/message-templates.js";
-import { loadHelp, Migrater } from "../index.js";
-const [HELP_TEXT, unknownArgTpl, noPendingMsg, noMorePendingMsg, appliedTpl] = await Promise.all([
-    loadHelp('migrate-up'),
-    loadMessage('errors/unknown-arg'),
-    loadMessage('status/no-pending'),
-    loadMessage('status/no-more-pending'),
-    loadMessage('status/applied'),
-]);
-const parseArgs = (argv) => {
-    const args = {
-        provider: null,
-        migratePath: null,
-        migrateRoot: null,
-        connection: null,
-        one: false,
-    };
-    const rest = argv.slice(2);
-    for (let i = 0; i < rest.length; i++) {
-        const a = rest[i];
-        if (a === '-h' || a === '--help') {
-            process.stderr.write(HELP_TEXT);
-            process.exit(0);
-        }
-        if (a === '--one') {
-            args.one = true;
-            continue;
-        }
-        let taken;
-        if ((taken = takeFlag(rest, i, a, '--provider'))) {
-            args.provider = taken.value;
-            i = taken.next;
-        }
-        else if ((taken = takeFlag(rest, i, a, '--migrations-path')) ||
-            (taken = takeFlag(rest, i, a, '--migrate-path'))) {
-            args.migratePath = taken.value;
-            i = taken.next;
-        }
-        else if ((taken = takeFlag(rest, i, a, '--migrations-root')) ||
-            (taken = takeFlag(rest, i, a, '--migrate-root'))) {
-            args.migrateRoot = taken.value;
-            i = taken.next;
-        }
-        else if ((taken = takeFlag(rest, i, a, '--connection'))) {
-            args.connection = taken.value;
-            i = taken.next;
-        }
-        else {
-            process.stderr.write(fillTemplate(unknownArgTpl, { arg: a }));
-            process.exit(2);
-        }
-    }
-    return args;
-};
-const resolveMigratePath = (args, dialect) => {
-    if (args.migratePath)
-        return args.migratePath;
-    const root = args.migrateRoot ?? 'sql';
-    return `${root}/${dialect}/migrations`;
-};
-const main = async () => {
-    const args = parseArgs(process.argv);
-    if (!args.provider) {
-        process.stderr.write(missingProviderMsg);
-        process.exit(2);
-    }
-    const dialect = requireDialect(args.provider);
-    const connection = requireConnection(dialect, args.connection);
-    const missing = await dialect.prerequisiteError(connection);
-    if (missing !== null) {
-        process.stderr.write(`${missing}\n`);
-        process.exit(2);
-    }
-    const migratePath = resolve(resolveMigratePath(args, dialect.name));
-    const names = await new Migrater(dialect).up({
-        connection,
-        migrationsPath: migratePath,
-        one: args.one,
-    });
-    if (names.length === 0) {
-        process.stdout.write(noPendingMsg);
-        return;
-    }
-    for (const name of names)
-        process.stdout.write(fillTemplate(appliedTpl, { name }));
-    if (!args.one)
-        process.stdout.write(noMorePendingMsg);
-};
-main().catch((e) => {
-    const err = e;
-    process.stderr.write(`${err?.stack ?? err?.message ?? String(e)}\n`);
-    process.exit(1);
-});

package/dist/cli-contract.d.ts

@@ -1,6 +0,0 @@
-export type { MigrateVerb } from './cli-spec.ts';
-export { migrateCommand, usageLine, programUsageText } from './cli-spec.ts';
-import { type MigrateVerb } from './cli-spec.ts';
-export declare const MIGRATE_VERBS: readonly ["setup", "up", "down", "create"];
-export declare const verbFromCommand: (command: string) => MigrateVerb;
-export declare const fillHelpTemplate: (text: string, command: string) => string;

package/dist/cli-contract.js

@@ -1,19 +0,0 @@
-export { migrateCommand, usageLine, programUsageText } from "./cli-spec.js";
-import { usageLine } from "./cli-spec.js";
-import { fillTemplate } from "./infrastructure/message-templates.js";
-export const MIGRATE_VERBS = ['setup', 'up', 'down', 'create'];
-export const verbFromCommand = (command) => {
-    const verb = command.replace(/^migrate-/, '');
-    if (verb !== 'init' &&
-        verb !== 'setup' &&
-        verb !== 'up' &&
-        verb !== 'down' &&
-        verb !== 'create') {
-        throw new Error(`Unknown migrate command "${command}"`);
-    }
-    return verb;
-};
-export const fillHelpTemplate = (text, command) => {
-    const usage = usageLine(verbFromCommand(command));
-    return fillTemplate(text, { command, usage });
-};

package/dist/cli.d.ts

@@ -1,9 +0,0 @@
-import type { ISqlDialect } from './abstractions/sql-dialect.ts';
-declare const missingProviderMsg: string;
-export { missingProviderMsg };
-export declare const requireDialect: (provider: string | null) => ISqlDialect;
-export declare const requireConnection: (dialect: ISqlDialect, fromFlag: string | null) => string;
-export declare const takeFlag: (rest: string[], i: number, arg: string, flag: string) => {
-    value: string;
-    next: number;
-} | undefined;

package/dist/cli.js

@@ -1,41 +0,0 @@
-import { connectionResolver, defaultDialectFactory } from "./infrastructure/default-factory.js";
-import { cliSpec } from "./cli-spec.js";
-import { fillTemplate, loadMessage } from "./infrastructure/message-templates.js";
-const missingProviderMsg = await loadMessage('errors/missing-provider');
-const unsupportedProviderTpl = await loadMessage('errors/unsupported-provider');
-const missingConnectionTpl = await loadMessage('errors/missing-connection');
-export { missingProviderMsg };
-export const requireDialect = (provider) => {
-    if (!provider) {
-        process.stderr.write(missingProviderMsg);
-        process.exit(2);
-    }
-    const dialect = defaultDialectFactory.tryGet(provider);
-    if (!dialect) {
-        process.stderr.write(fillTemplate(unsupportedProviderTpl, { provider }));
-        process.exit(2);
-    }
-    return dialect;
-};
-export const requireConnection = (dialect, fromFlag) => {
-    const connection = connectionResolver.resolve(dialect, fromFlag);
-    if (!connection) {
-        process.stderr.write(fillTemplate(missingConnectionTpl, {
-            envVars: dialect.connectionEnvironmentVariables.join(cliSpec.env_var_list_separator),
-        }));
-        process.exit(2);
-    }
-    return connection;
-};
-export const takeFlag = (rest, i, arg, flag) => {
-    const eq = `${flag}=`;
-    if (arg === flag) {
-        const value = rest[i + 1];
-        if (value === undefined)
-            return undefined;
-        return { value, next: i + 1 };
-    }
-    if (arg.startsWith(eq))
-        return { value: arg.slice(eq.length), next: i };
-    return undefined;
-};

package/dist/create-sequence.d.ts

@@ -1,4 +0,0 @@
-export declare const MIGRATION_NAME_RE: RegExp;
-export declare const isMigrationName: (name: string) => boolean;
-export declare const nextSequence: (filenames: Iterable<string>) => number;
-export declare const pad4: (n: number) => string;

package/dist/create-sequence.js

@@ -1,16 +0,0 @@
-export const MIGRATION_NAME_RE = /^[a-z][a-z0-9_]*$/;
-const SEQ_RE = /^(\d{1,4})_.*_up\.sql$/;
-export const isMigrationName = (name) => MIGRATION_NAME_RE.test(name);
-export const nextSequence = (filenames) => {
-    let max = 0;
-    for (const name of filenames) {
-        const m = SEQ_RE.exec(name);
-        if (!m)
-            continue;
-        const n = Number.parseInt(m[1], 10);
-        if (n > max)
-            max = n;
-    }
-    return max + 1;
-};
-export const pad4 = (n) => String(n).padStart(4, '0');

package/dist/datasource-migrate.d.ts

@@ -1,31 +0,0 @@
-import type { MigrationClient } from './migration-client.ts';
-export { normalizeDialect } from './sql.ts';
-export type { MigrationClient, MigrationRow, MigrationSqlParam, SqliteRawDatabase, } from './migration-client.ts';
-export { applyMysqlDdlViaTextProtocol } from './dialects/mysql-dialect.ts';
-/** One discovered migration: its up script and the rollback sibling when present. */
-export interface MigrationDescriptor {
-    name: string;
-    upPath: string;
-    downPath: string | null;
-}
-export declare function discoverMigrations({ migratePath, dialect, }: {
-    migratePath: string;
-    dialect: string;
-}): Promise<MigrationDescriptor[]>;
-export declare function checksum(text: string): string;
-export declare function applyOneUp({ client, migrations, env, }: {
-    client: MigrationClient;
-    migrations: MigrationDescriptor[];
-    env?: NodeJS.ProcessEnv;
-}): Promise<{
-    applied: boolean;
-    name: string | null;
-}>;
-export declare function applyOneDown({ client, migrations, env, }: {
-    client: MigrationClient;
-    migrations: MigrationDescriptor[];
-    env?: NodeJS.ProcessEnv;
-}): Promise<{
-    rolledBack: boolean;
-    name: string | null;
-}>;

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();
-            },
-        };
-    }
-}