@deterministic-code/migraters 0.0.2 → 0.0.3

package/typescript/src/generate-help.ts

@@ -0,0 +1,173 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { parse } from 'yaml';
+
+type HelpArg = {
+  flag: string;
+  placeholder?: string;
+  required: boolean;
+  help: string;
+};
+
+type HelpCommand = {
+  verb: string;
+  summary: string;
+  examples: string;
+  show_connection_env?: boolean;
+  args: HelpArg[];
+};
+
+type HelpSpec = {
+  providers: string[];
+  connection_environment: Record<string, string[]>;
+  commands: HelpCommand[];
+};
+
+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');
+
+const requireString = (value: unknown, path: string): string => {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new Error(`cli.yaml: ${path} must be a non-empty string`);
+  }
+  return value;
+};
+
+const parseHelpSpec = (raw: unknown): HelpSpec => {
+  if (raw === null || typeof raw !== 'object') {
+    throw new Error('cli.yaml: root must be a mapping');
+  }
+  const doc = raw as Record<string, unknown>;
+  if (!Array.isArray(doc.providers) || doc.providers.some((p) => typeof p !== 'string')) {
+    throw new Error('cli.yaml: providers must be a string list');
+  }
+  const envRaw = doc.connection_environment;
+  if (envRaw === null || typeof envRaw !== 'object' || Array.isArray(envRaw)) {
+    throw new Error('cli.yaml: connection_environment must be a mapping');
+  }
+  const connection_environment: Record<string, string[]> = {};
+  for (const [dialect, vars] of Object.entries(envRaw)) {
+    if (!Array.isArray(vars) || vars.some((v) => typeof v !== 'string')) {
+      throw new Error(`cli.yaml: connection_environment.${dialect} must be a string list`);
+    }
+    connection_environment[dialect] = vars;
+  }
+  if (!Array.isArray(doc.commands)) {
+    throw new Error('cli.yaml: commands must be a list');
+  }
+  const commands = doc.commands.map((item, i) => {
+    if (item === null || typeof item !== 'object') {
+      throw new Error(`cli.yaml: commands[${i}] must be a mapping`);
+    }
+    const row = item as Record<string, unknown>;
+    const verb = requireString(row.verb, `commands[${i}].verb`);
+    if (!Array.isArray(row.args)) {
+      throw new Error(`cli.yaml: commands.${verb}.args must be a list`);
+    }
+    return {
+      verb,
+      summary: requireString(row.summary, `commands.${verb}.summary`),
+      examples: requireString(row.examples, `commands.${verb}.examples`),
+      show_connection_env: row.show_connection_env === true,
+      args: row.args.map((arg, j) => {
+        if (arg === null || typeof arg !== 'object') {
+          throw new Error(`cli.yaml: commands.${verb}.args[${j}] must be a mapping`);
+        }
+        const a = arg as Record<string, unknown>;
+        return {
+          flag: requireString(a.flag, `commands.${verb}.args[${j}].flag`),
+          placeholder: typeof a.placeholder === 'string' ? a.placeholder : undefined,
+          required: a.required === true,
+          help: requireString(a.help, `commands.${verb}.args[${j}].help`),
+        };
+      }),
+    };
+  });
+  return {
+    providers: doc.providers as string[],
+    connection_environment,
+    commands,
+  };
+};
+
+const wrapArgHelp = (flag: string, help: string, flagWidth: number): string => {
+  const lines = help.replace(/\s+$/, '').split('\n');
+  const indent = `  ${flag.padEnd(flagWidth)}  `;
+  const cont = ' '.repeat(indent.length);
+  return [indent + lines[0], ...lines.slice(1).map((line) => cont + line.trimStart())].join('\n');
+};
+
+const renderFlags = (args: HelpArg[]): string => {
+  const flagWidth = Math.max(...args.map((a) => a.flag.length));
+  return args.map((a) => wrapArgHelp(a.flag, a.help, flagWidth)).join('\n');
+};
+
+const renderConnectionEnv = (spec: HelpSpec): string => {
+  const nameWidth = Math.max(...spec.providers.map((p) => p.length));
+  const lines = spec.providers.map((name) => {
+    const vars = spec.connection_environment[name];
+    if (!vars) {
+      throw new Error(`cli.yaml: connection_environment missing ${name}`);
+    }
+    return `  ${name.padEnd(nameWidth)}  ${vars.join(', ')}`;
+  });
+  return [
+    'Per-dialect env vars consulted when --connection is omitted:',
+    ...lines,
+  ].join('\n');
+};
+
+const indentBlock = (text: string): string =>
+  text
+    .split('\n')
+    .map((line) => (line.length === 0 ? '' : `  ${line}`))
+    .join('\n');
+
+export const renderHelpTemplate = (spec: HelpSpec, command: HelpCommand): string => {
+  const parts = [
+    '{{usage}}',
+    '',
+    command.summary.replace(/\s+$/, ''),
+    '',
+    renderFlags(command.args),
+    '',
+    'Examples:',
+    indentBlock(command.examples.replace(/\s+$/, '')),
+  ];
+  if (command.show_connection_env) {
+    parts.push('', renderConnectionEnv(spec));
+  }
+  return `${parts.join('\n')}\n`;
+};
+
+export const renderHelpTemplates = (raw: unknown): Record<string, string> => {
+  const spec = parseHelpSpec(raw);
+  return Object.fromEntries(spec.commands.map((c) => [c.verb, renderHelpTemplate(spec, c)]));
+};
+
+export const generateHelpFiles = async (): Promise<string[]> => {
+  const files = renderHelpTemplates(parse(await readFile(CLI_YAML, 'utf8')));
+  const written: string[] = [];
+  const packagedDir = join(dirname(fileURLToPath(import.meta.url)), '..');
+  const packagedCli = join(packagedDir, 'cli.yaml');
+  await writeFile(packagedCli, await readFile(CLI_YAML, 'utf8'));
+  written.push(packagedCli);
+  const packagedBundle = join(packagedDir, 'bundle.yaml');
+  await writeFile(packagedBundle, await readFile(join(REPO_ROOT, 'bundle.yaml'), 'utf8'));
+  written.push(packagedBundle);
+  for (const [verb, text] of Object.entries(files)) {
+    const path = join(HELP_DIR, `${verb}.txt`);
+    await writeFile(path, text);
+    written.push(path);
+  }
+  return written;
+};
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? '').href) {
+  const written = await generateHelpFiles();
+  for (const path of written) {
+    console.log(path);
+  }
+}

package/typescript/src/help.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest';
+import {
+  fillHelpTemplate,
+  migrateCommand,
+  verbFromCommand,
+  type MigrateVerb,
+} from './cli-contract.ts';
+import { loadHelp, loadProgramUsage } from './help.ts';
+
+const VERBS: MigrateVerb[] = ['setup', 'up', 'down', 'create'];
+
+describe('unified help loader', () => {
+  it('maps migrate-<verb> onto the shared template file', () => {
+    expect(verbFromCommand('migrate-create')).toBe('create');
+    expect(migrateCommand('create')).toBe('migrate-create');
+    expect(() => verbFromCommand('MigrateRunner')).toThrow(/Unknown migrate command/);
+  });
+
+  it('fills {{command}} and {{usage}} from cli.yaml', () => {
+    const filled = fillHelpTemplate('{{usage}}\n  {{command}} --name x\n', 'migrate-create');
+    expect(filled.startsWith('Usage: migrate-create --provider')).toBe(true);
+    expect(filled).toContain('migrate-create --name x');
+    expect(filled).not.toContain('{{');
+  });
+
+  it('loads program usage with the same migrate-<verb> Usage lines', async () => {
+    const text = await loadProgramUsage();
+    for (const verb of VERBS) {
+      expect(text).toContain(`Usage: ${migrateCommand(verb)} --provider`);
+    }
+    expect(text).toContain('Usage: migrate-init');
+    expect(text).not.toContain('{{command}}');
+    expect(text).not.toContain('MigrateRunner');
+    expect(text).not.toMatch(/^Usage: (create|up|down|setup) /m);
+  });
+
+  it('loads the same filled help the rust and csharp runners produce', async () => {
+    for (const verb of VERBS) {
+      const command = migrateCommand(verb);
+      const text = await loadHelp(command);
+      expect(text.startsWith(`Usage: ${command} --provider`)).toBe(true);
+      expect(text).toContain(`${command} --provider sqlite`);
+      expect(text).not.toContain('{{command}}');
+      expect(text).not.toMatch(/^Usage: (create|up|down|setup) /m);
+      expect(text).not.toMatch(/^\s+(create|up|down|setup) --provider/m);
+    }
+  });
+});

package/typescript/src/help.ts

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

package/typescript/src/index.ts

@@ -0,0 +1,23 @@
+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/typescript/src/infrastructure/connection-resolver.ts

@@ -0,0 +1,18 @@
+import type { ISqlDialect } from '../abstractions/sql-dialect.ts';
+
+export class ConnectionResolver {
+  constructor(private readonly env: NodeJS.ProcessEnv = process.env) {}
+
+  fromEnvironment(dialect: ISqlDialect): string | null {
+    for (const name of dialect.connectionEnvironmentVariables) {
+      const value = this.env[name];
+      if (value) return value;
+    }
+    return null;
+  }
+
+  resolve(dialect: ISqlDialect, fromFlag: string | null): string | null {
+    if (fromFlag) return fromFlag;
+    return this.fromEnvironment(dialect);
+  }
+}

package/typescript/src/infrastructure/default-factory.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { defaultDialectFactory } from './default-factory.ts';
+
+describe('defaultDialectFactory', () => {
+  it('registers every dialect name and alias', () => {
+    const names = defaultDialectFactory.all().map((d) => d.name);
+    for (const name of names) {
+      expect(['sqlite', 'postgres', 'mysql', 'sqlserver', 'oracle']).toContain(name);
+    }
+    if (names.includes('sqlite')) {
+      expect(defaultDialectFactory.get('sqlite3').name).toBe('sqlite');
+    }
+    if (names.includes('postgres')) {
+      expect(defaultDialectFactory.get('postgresql').name).toBe('postgres');
+    }
+    if (names.includes('mysql')) {
+      expect(defaultDialectFactory.get('mariadb').name).toBe('mysql');
+    }
+    if (names.includes('sqlserver')) {
+      expect(defaultDialectFactory.get('mssql').name).toBe('sqlserver');
+      expect(defaultDialectFactory.get('mssqlserver').name).toBe('sqlserver');
+      expect(defaultDialectFactory.get('ms-sql-server').name).toBe('sqlserver');
+    }
+    if (names.includes('oracle')) {
+      expect(defaultDialectFactory.get('ora').name).toBe('oracle');
+    }
+    expect(defaultDialectFactory.tryGet('nope')).toBeUndefined();
+    expect(() => defaultDialectFactory.get('nope')).toThrow(/Unknown SQL dialect/);
+  });
+});

package/typescript/src/infrastructure/default-factory.ts

@@ -0,0 +1,41 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { SqlDialectFactory } from '../abstractions/sql-dialect-factory.ts';
+import type { ISqlDialect } from '../abstractions/sql-dialect.ts';
+import { ConnectionResolver } from './connection-resolver.ts';
+
+const DIALECT_PACKAGES = [
+  'sqlite',
+  'postgres',
+  'mysql',
+  'sqlserver',
+  'oracle',
+] as const;
+
+const dialectEntry = (name: string): string => {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const ext = import.meta.url.endsWith('.ts') ? '.ts' : '.js';
+  return join(here, '..', '..', 'dialects', name, 'src', `index${ext}`);
+};
+
+const loadInstalledDialects = async (): Promise<ISqlDialect[]> => {
+  const loaded: ISqlDialect[] = [];
+  for (const name of DIALECT_PACKAGES) {
+    const file = dialectEntry(name);
+    if (!existsSync(file)) continue;
+    try {
+      const mod = (await import(pathToFileURL(file).href)) as { createDialect?: () => ISqlDialect };
+      if (typeof mod.createDialect === 'function') {
+        loaded.push(mod.createDialect());
+      }
+    } catch {
+      // Dialect is compiled and drivers are installed by migrate-init.
+    }
+  }
+  return loaded;
+};
+
+export const defaultDialectFactory = new SqlDialectFactory(await loadInstalledDialects());
+
+export const connectionResolver = new ConnectionResolver();

package/typescript/src/infrastructure/interop-default.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from 'vitest';
+import { interopDefault } from './interop-default.ts';
+
+describe('interopDefault', () => {
+  it('prefers default when present and falls back to the module namespace', () => {
+    expect(interopDefault({ default: { connect: 1 } })).toEqual({ connect: 1 });
+    expect(interopDefault({ connect: 2 })).toEqual({ connect: 2 });
+  });
+});

package/typescript/src/infrastructure/interop-default.ts

@@ -0,0 +1,2 @@
+export const interopDefault = <T>(mod: { default?: T }): T =>
+  (mod.default ?? mod) as T;

package/typescript/src/infrastructure/message-templates.ts

@@ -0,0 +1,30 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { templatesRoot } from './templates-root.ts';
+
+export const fillTemplate = (text: string, vars: Record<string, string>): string => {
+  let out = text;
+  for (const [key, value] of Object.entries(vars)) {
+    out = out.replaceAll(`{{${key}}}`, value);
+  }
+  return out;
+};
+
+export const loadMessage = async (
+  relativePath: string,
+  vars: Record<string, string> = {},
+): Promise<string> => {
+  const text = await readFile(
+    join(templatesRoot(), 'messages', `${relativePath}.txt`),
+    'utf8',
+  );
+  return fillTemplate(text, vars);
+};
+
+export const loadScaffold = async (
+  name: 'up' | 'down',
+  vars: Record<string, string>,
+): Promise<string> => {
+  const text = await readFile(join(templatesRoot(), 'scaffold', `${name}.sql`), 'utf8');
+  return fillTemplate(text, vars);
+};

package/typescript/src/infrastructure/mysql-text-protocol.ts

@@ -0,0 +1,7 @@
+/** why: DDL statements (DROP/CREATE PROCEDURE) reject prepared-statement protocol (MySQL 1295) */
+export async function applyMysqlDdlViaTextProtocol(
+  conn: { query: (sql: string) => Promise<unknown> },
+  sql: string,
+): Promise<void> {
+  await conn.query(sql);
+}

package/typescript/src/infrastructure/split-on-go.ts

@@ -0,0 +1,19 @@
+const GO_LINE = /^\s*GO\s*$/i;
+
+/** Split migration SQL on whole-line GO batch separators. */
+export function splitOnGo(text: string): string[] {
+  const batches: string[] = [];
+  let buf = '';
+  for (const line of text.replace(/\r\n/g, '\n').split('\n')) {
+    if (GO_LINE.test(line)) {
+      const s = buf.trim();
+      if (s.length > 0) batches.push(s);
+      buf = '';
+      continue;
+    }
+    buf = buf.length > 0 ? `${buf}\n${line}` : line;
+  }
+  const tail = buf.trim();
+  if (tail.length > 0) batches.push(tail);
+  return batches;
+}

package/typescript/src/infrastructure/sql-templates.ts

@@ -0,0 +1,10 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { SqlDialect } from '../sql.ts';
+import { templatesRoot } from './templates-root.ts';
+
+export const readSqlTemplate = async (
+  dialect: SqlDialect,
+  name: 'migrates' | 'migrate_logs',
+): Promise<string> =>
+  (await readFile(join(templatesRoot(), 'sql', dialect, `${name}.sql`), 'utf8')).trim();

package/typescript/src/infrastructure/templates-root.ts

@@ -0,0 +1,16 @@
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+
+/** Repo `shared/templates`; after build, `dist/templates` (copied from shared). */
+export const templatesRoot = (): string => {
+  const normalized = HERE.replaceAll('\\', '/');
+  if (normalized.endsWith('/dist/src/infrastructure') || normalized.endsWith('/dist.tmp/src/infrastructure')) {
+    return join(HERE, '..', '..', 'templates');
+  }
+  if (normalized.endsWith('/dist/infrastructure')) {
+    return join(HERE, '..', 'templates');
+  }
+  return join(HERE, '..', '..', '..', 'shared', 'templates');
+};

package/typescript/src/init-select.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import { loadSelectedPackages, resolveInitDialects } from './init-select.ts';
+
+describe('init dialect selection', () => {
+  it('accepts aliases and keeps cli.yaml order', () => {
+    expect(resolveInitDialects(['ora', 'pg'], false)).toEqual(['postgres', 'oracle']);
+  });
+
+  it('restores every provider for --all', () => {
+    expect(resolveInitDialects([], true)).toEqual([
+      'sqlite',
+      'postgres',
+      'mysql',
+      'sqlserver',
+      'oracle',
+    ]);
+  });
+
+  it('reads typescript packages from bundle.yaml', async () => {
+    const selected = await loadSelectedPackages(['sqlite', 'postgres']);
+    expect(selected.packages.map((p) => p.name).sort()).toEqual(['better-sqlite3', 'pg']);
+    expect(selected.allDriverPackages).toEqual(
+      expect.arrayContaining(['better-sqlite3', 'pg', 'mysql2', 'mssql', 'oracledb']),
+    );
+  });
+
+  it('reads csharp packages and versions from bundle.yaml', async () => {
+    const selected = await loadSelectedPackages(['sqlite', 'sqlserver'], 'csharp');
+    expect(selected.packages).toEqual([
+      { name: 'Microsoft.Data.Sqlite', version: '9.0.0' },
+      { name: 'Microsoft.Data.SqlClient', version: '6.0.2' },
+    ]);
+  });
+});

package/typescript/src/init-select.ts

@@ -0,0 +1,77 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse } from 'yaml';
+import { cliSpec } from './cli-spec.ts';
+
+export type SelectedDialects = {
+  names: string[];
+  packages: { name: string }[];
+  allDriverPackages: string[];
+};
+
+const stripKey = (raw: string): string => raw.replace(/[\s_-]/g, '').toLowerCase();
+
+export const normalizeInitProvider = (raw: string): string | undefined => {
+  const key = stripKey(raw);
+  const direct = cliSpec.providers.find((p) => stripKey(p) === key);
+  if (direct) return direct;
+  return cliSpec.provider_aliases[key];
+};
+
+export const resolveInitDialects = (raw: string[], all: boolean): string[] => {
+  if (all) return [...cliSpec.providers];
+  if (raw.length === 0) {
+    throw new Error('pass --dialect <provider> at least once, or --all');
+  }
+  const selected = new Set<string>();
+  for (const value of raw) {
+    const name = normalizeInitProvider(value);
+    if (!name) {
+      throw new Error(`unsupported provider: ${value}`);
+    }
+    selected.add(name);
+  }
+  return cliSpec.providers.filter((name) => selected.has(name));
+};
+
+export type BundlePackage = {
+  name: string;
+  version?: string;
+};
+
+type BundleDialect = {
+  packages?: BundlePackage[];
+};
+
+type BundleDoc = {
+  languages?: Record<string, { dialects?: Record<string, BundleDialect> }>;
+};
+
+export const bundleYamlPath = (): string => {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(here, '..', 'bundle.yaml'),
+    join(here, '..', '..', 'bundle.yaml'),
+    join(process.cwd(), 'bundle.yaml'),
+  ];
+  const found = candidates.find((candidate) => existsSync(candidate));
+  if (!found) {
+    throw new Error('bundle.yaml not found');
+  }
+  return found;
+};
+
+export const loadSelectedPackages = async (
+  dialects: string[],
+  language = 'typescript',
+): Promise<SelectedDialects> => {
+  const raw = parse(await readFile(bundleYamlPath(), 'utf8')) as BundleDoc;
+  const byName = raw.languages?.[language]?.dialects ?? {};
+  const allDriverPackages = [
+    ...new Set(Object.values(byName).flatMap((d) => (d.packages ?? []).map((p) => p.name))),
+  ];
+  const packages = dialects.flatMap((name) => byName[name]?.packages ?? []);
+  return { names: dialects, packages, allDriverPackages };
+};

package/typescript/src/migrater.ts

@@ -0,0 +1,92 @@
+import { mkdir, readdir, writeFile } from 'node:fs/promises';
+import type {
+  CreateArg,
+  CreateResponse,
+  DownArg,
+  IMigrater,
+  SetupArg,
+  UpArg,
+} from './abstractions/migrater.ts';
+import type { ISqlDialect } from './abstractions/sql-dialect.ts';
+import { isMigrationName, nextSequence, pad4 } from './create-sequence.ts';
+import { applyOneDown, applyOneUp, discoverMigrations } from './datasource-migrate.ts';
+import { defaultDialectFactory } from './infrastructure/default-factory.ts';
+import { fillTemplate, loadMessage, loadScaffold } from './infrastructure/message-templates.ts';
+
+const invalidNameTpl = await loadMessage('errors/invalid-name');
+
+export class Migrater implements IMigrater {
+  constructor(private readonly dialect: ISqlDialect) {}
+
+  get name(): string {
+    return this.dialect.name;
+  }
+
+  async setup({ connection, migrationsPath }: SetupArg): Promise<void> {
+    await this.dialect.prepareSetup(connection);
+    const client = await this.dialect.createClient(connection);
+    try {
+      await client.exec(this.dialect.migratesDdl);
+      await client.exec(this.dialect.migrateLogsDdl);
+      await mkdir(migrationsPath, { recursive: true });
+    } finally {
+      await client.close();
+    }
+  }
+
+  async up({ connection, migrationsPath, one = false }: UpArg): Promise<string[]> {
+    const client = await this.dialect.createClient(connection);
+    try {
+      const migrations = await discoverMigrations({
+        migratePath: migrationsPath,
+        dialect: this.dialect.name,
+      });
+      const applied: string[] = [];
+      for (;;) {
+        const result = await applyOneUp({ client, migrations });
+        if (!result.applied || result.name == null) break;
+        applied.push(result.name);
+        if (one) break;
+      }
+      return applied;
+    } finally {
+      await client.close();
+    }
+  }
+
+  async down({ connection, migrationsPath }: DownArg): Promise<string | null> {
+    const client = await this.dialect.createClient(connection);
+    try {
+      const migrations = await discoverMigrations({
+        migratePath: migrationsPath,
+        dialect: this.dialect.name,
+      });
+      const result = await applyOneDown({ client, migrations });
+      return result.rolledBack ? result.name : null;
+    } finally {
+      await client.close();
+    }
+  }
+
+  async create({ name, migrationsPath }: CreateArg): Promise<CreateResponse> {
+    if (!isMigrationName(name)) {
+      throw new Error(fillTemplate(invalidNameTpl, { name }));
+    }
+    await mkdir(migrationsPath, { recursive: true });
+    let entries: string[] = [];
+    try {
+      entries = await readdir(migrationsPath);
+    } catch (err) {
+      if (!(err instanceof Error && 'code' in err && err.code === 'ENOENT')) throw err;
+    }
+    const seq = pad4(nextSequence(entries));
+    const upName = `${seq}_${name}_up.sql`;
+    const downName = `${seq}_${name}_down.sql`;
+    await writeFile(`${migrationsPath}/${upName}`, await loadScaffold('up', { name }));
+    await writeFile(`${migrationsPath}/${downName}`, await loadScaffold('down', { name }));
+    return { upName, downName };
+  }
+}
+
+export const getMigrater = (provider: string): IMigrater =>
+  new Migrater(defaultDialectFactory.get(provider));