@deterministic-code/migraters 0.0.1 → 0.0.2

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

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

package/src/dialects/postgres-dialect.ts

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

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

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

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

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

package/src/dialects/sqlite-dialect.ts

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

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

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

package/src/dialects/sqlserver-dialect.ts

@@ -1,87 +0,0 @@
-import type { Request as MssqlRequest } from 'mssql';
-import type { MigrationClient, MigrationSqlParam } from '../migration-client.ts';
-import { interopDefault } from '../infrastructure/interop-default.ts';
-import { readSqlTemplate } from '../infrastructure/sql-templates.ts';
-import { SqlDialectBase } from '../abstractions/sql-dialect-base.ts';
-
-const [migratesDdl, migrateLogsDdl] = await Promise.all([
-  readSqlTemplate('sqlserver', 'migrates'),
-  readSqlTemplate('sqlserver', 'migrate_logs'),
-]);
-
-const bindMssql = (
-  req: Pick<MssqlRequest, 'input'>,
-  sql: string,
-  params: MigrationSqlParam[],
-): string => {
-  let n = 0;
-  return sql.replace(/\?/g, () => {
-    const name = `p${n}`;
-    req.input(name, params[n]);
-    n++;
-    return `@${name}`;
-  });
-};
-
-export class SqlServerDialect extends SqlDialectBase {
-  readonly name = 'sqlserver' as const;
-  readonly connectionEnvironmentVariables = ['MSSQL_URL', 'DATABASE_URL'] as const;
-  readonly migratesDdl = migratesDdl;
-  readonly migrateLogsDdl = migrateLogsDdl;
-
-  quoteIdent(ident: string): string {
-    return `[${ident}]`;
-  }
-
-  nowExpr(): string {
-    return 'SYSUTCDATETIME()';
-  }
-
-  limitClause(n: number): string {
-    return `OFFSET 0 ROWS FETCH NEXT ${n} ROWS ONLY`;
-  }
-
-  async createClient(connection: string): Promise<MigrationClient> {
-    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/src/generate-help.test.ts

@@ -1,33 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { parse } from 'yaml';
-import { describe, expect, it } from 'vitest';
-import { generateHelpFiles, renderHelpTemplates } from './generate-help.ts';
-
-const REPO_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
-const CLI_YAML = join(REPO_ROOT, 'cli.yaml');
-const HELP_DIR = join(REPO_ROOT, 'shared', 'templates', 'help');
-
-describe('generate-help', () => {
-  it('shared/templates/help matches cli.yaml', async () => {
-    const generated = renderHelpTemplates(parse(await readFile(CLI_YAML, 'utf8')));
-    for (const [verb, text] of Object.entries(generated)) {
-      const onDisk = await readFile(join(HELP_DIR, `${verb}.txt`), 'utf8');
-      expect(onDisk, verb).toBe(text);
-    }
-  });
-
-  it('writes the verb templates', async () => {
-    const written = await generateHelpFiles();
-    expect(written.map((p) => p.slice(p.lastIndexOf('/') + 1)).sort()).toEqual([
-      'bundle.yaml',
-      'cli.yaml',
-      'create.txt',
-      'down.txt',
-      'init.txt',
-      'setup.txt',
-      'up.txt',
-    ]);
-  });
-});