@deterministic-code/migraters 0.0.1 → 0.0.3

package/{src/dialects → typescript/dialects/sqlite/src}/sqlite-dialect.test.ts

@@ -51,7 +51,7 @@ describe('SqliteDialect', () => {
     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');
+    const { pathExists } = await import('../../../src/path-exists.ts');
     expect(await pathExists(join(dir, 'nested', 'db'))).toBe(true);
     await dialect.prepareSetup(':memory:');
   });

package/{src/dialects → typescript/dialects/sqlite/src}/sqlite-dialect.ts

@@ -1,10 +1,10 @@
 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';
+import type { MigrationClient, MigrationRow, MigrationSqlParam } from '../../../src/migration-client.ts';
+import { pathExists } from '../../../src/path-exists.ts';
+import { readSqlTemplate } from '../../../src/infrastructure/sql-templates.ts';
+import { fillTemplate, loadMessage } from '../../../src/infrastructure/message-templates.ts';
+import { SqlDialectBase } from '../../../src/abstractions/sql-dialect-base.ts';
 
 const [migratesDdl, migrateLogsDdl, sqlitePrerequisiteTpl] = await Promise.all([
   readSqlTemplate('sqlite', 'migrates'),

package/typescript/dialects/sqlserver/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@deterministic-code/migraters-sqlserver",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@types/mssql": "*",
+    "mssql": "*"
+  }
+}

package/typescript/dialects/sqlserver/src/index.ts

@@ -0,0 +1,4 @@
+import { SqlServerDialect } from './sqlserver-dialect.ts';
+
+export const createDialect = (): SqlServerDialect => new SqlServerDialect();
+export { SqlServerDialect };

package/{src/dialects → typescript/dialects/sqlserver/src}/sqlserver-dialect.test.ts

@@ -68,6 +68,16 @@ describe('SqlServerDialect', () => {
     await dialect.prepareSetup('mssql://x');
   });
 
+  it('createDatabaseIfMissing creates the database unless it is master', async () => {
+    await dialect.createDatabaseIfMissing(
+      'Server=sqlserver,1433;User Id=sa;Password=x;Database=proof',
+    );
+    expect(mssql.state.batches[0]).toContain('CREATE DATABASE [proof]');
+    await dialect.createDatabaseIfMissing(
+      'Server=sqlserver,1433;User Id=sa;Password=x;Database=master',
+    );
+  });
+
   it('createClient binds ? as @pN and handles empty recordsets', async () => {
     const client = await dialect.createClient('Server=localhost');
     expect(client.dialect).toBe('sqlserver');

package/{src/dialects → typescript/dialects/sqlserver/src}/sqlserver-dialect.ts

@@ -1,8 +1,8 @@
 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';
+import type { MigrationClient, MigrationSqlParam } from '../../../src/migration-client.ts';
+import { interopDefault } from '../../../src/infrastructure/interop-default.ts';
+import { readSqlTemplate } from '../../../src/infrastructure/sql-templates.ts';
+import { SqlDialectBase } from '../../../src/abstractions/sql-dialect-base.ts';
 
 const [migratesDdl, migrateLogsDdl] = await Promise.all([
   readSqlTemplate('sqlserver', 'migrates'),
@@ -41,6 +41,22 @@ export class SqlServerDialect extends SqlDialectBase {
     return `OFFSET 0 ROWS FETCH NEXT ${n} ROWS ONLY`;
   }
 
+  async createDatabaseIfMissing(connection: string): Promise<void> {
+    const match = /(?:^|;)Database=([^;]+)/i.exec(connection);
+    const name = match?.[1]?.trim();
+    if (!name || /^master$/i.test(name)) return;
+    const admin = connection.replace(/(^|;)Database=[^;]*/i, '$1Database=master');
+    const { default: mssql } = await import('mssql');
+    const pool = await mssql.connect(admin);
+    try {
+      await pool.request().batch(
+        `IF DB_ID(N'${name.replaceAll("'", "''")}') IS NULL CREATE DATABASE [${name.replaceAll(']', ']]')}];`,
+      );
+    } finally {
+      await pool.close();
+    }
+  }
+
   async createClient(connection: string): Promise<MigrationClient> {
     const mssql = interopDefault(await import('mssql'));
     const pool = await mssql.connect(connection);

package/typescript/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@deterministic-code/migraters-typescript",
+  "version": "0.0.1",
+  "private": true,
+  "description": "TypeScript migrate runner for deterministic-code.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "migrate-up": "./dist/src/bin/migrate-up.js",
+    "migrate-down": "./dist/src/bin/migrate-down.js",
+    "migrate-setup": "./dist/src/bin/migrate-setup.js",
+    "migrate-create": "./dist/src/bin/migrate-create.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "dialects",
+    "cli.yaml",
+    "bundle.yaml",
+    "tsconfig.build.json"
+  ],
+  "scripts": {
+    "build": "rm -rf dist.tmp && tsc -p tsconfig.build.json --outDir dist.tmp && cp -R ../shared/templates dist.tmp/templates && cp ../cli.yaml dist.tmp/cli.yaml && rm -rf dist && mv dist.tmp dist",
+    "typecheck": "tsc -p tsconfig.src.json --noEmit",
+    "test": "npm run build && node ../orchestrator/dist/migrate-init.js --language typescript --all && vitest run --coverage",
+    "test:coverage": "vitest run --coverage",
+    "generate:help": "node --experimental-strip-types src/generate-help.ts",
+    "format": "prettier --write ."
+  },
+  "dependencies": {
+    "typescript": "^5.8.0",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "prettier": "^3.9.6",
+    "vitest": "^3.2.4"
+  }
+}

package/{src → typescript/src}/abstractions/sql-dialect-base.ts

@@ -30,6 +30,8 @@ export abstract class SqlDialectBase implements ISqlDialect {
 
   async prepareSetup(_connection: string): Promise<void> {}
 
+  async createDatabaseIfMissing(_connection: string): Promise<void> {}
+
   abstract createClient(
     connection: string,
   ): Promise<import('../migration-client.ts').MigrationClient>;

package/{src → typescript/src}/abstractions/sql-dialect.ts

@@ -13,5 +13,6 @@ export interface ISqlDialect {
   translatePlaceholders(sql: string): string;
   prerequisiteError(connection: string): Promise<string | null>;
   prepareSetup(connection: string): Promise<void>;
+  createDatabaseIfMissing(connection: string): Promise<void>;
   createClient(connection: string): Promise<MigrationClient>;
 }

package/{src → typescript/src}/bin/migrate-down.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// Rolls back the most recently applied migration (one step). DESTRUCTIVE: prints a random 4-letter uppercase confirmation token and refuses to proceed unless the user types it back on stdin. Pass --confirm <TOKEN> matching the printed token to bypass the interactive prompt (CI / scripted use).
+// Rolls back the most recently applied migration (one step). DESTRUCTIVE: refuses to proceed unless the user types confirm on stdin, or passes --confirm.
 
 import { resolve } from 'node:path';
 import { createInterface } from 'node:readline/promises';
@@ -11,8 +11,7 @@ const [
   HELP_TEXT,
   unknownArgTpl,
   destructiveHeaderTpl,
-  confirmMismatchTpl,
-  confirmTtyRequiredTpl,
+  confirmTtyRequiredMsg,
   confirmPromptTpl,
   confirmTokenMismatchMsg,
   noRollbackMsg,
@@ -21,7 +20,6 @@ const [
   loadHelp('migrate-down'),
   loadMessage('errors/unknown-arg'),
   loadMessage('down/destructive-header'),
-  loadMessage('down/confirm-mismatch'),
   loadMessage('down/confirm-tty-required'),
   loadMessage('down/confirm-prompt'),
   loadMessage('down/confirm-token-mismatch'),
@@ -35,13 +33,13 @@ const parseArgs = (argv: string[]) => {
     migratePath: string | null;
     migrateRoot: string | null;
     connection: string | null;
-    confirm: string | null;
+    confirm: boolean;
   } = {
     provider: null,
     migratePath: null,
     migrateRoot: null,
     connection: null,
-    confirm: null,
+    confirm: false,
   };
   const rest = argv.slice(2);
   for (let i = 0; i < rest.length; i++) {
@@ -69,9 +67,8 @@ const parseArgs = (argv: string[]) => {
     } else if ((taken = takeFlag(rest, i, a, '--connection'))) {
       args.connection = taken.value;
       i = taken.next;
-    } else if ((taken = takeFlag(rest, i, a, '--confirm'))) {
-      args.confirm = taken.value;
-      i = taken.next;
+    } else if (a === '--confirm') {
+      args.confirm = true;
     } else {
       process.stderr.write(fillTemplate(unknownArgTpl, { arg: a }));
       process.exit(2);
@@ -89,24 +86,15 @@ const resolveMigratePath = (
   return `${root}/${dialect}/migrations`;
 };
 
-const randomToken = (): string => {
-  const alphabet = 'ABCDEFGHJKLMNPQRSTUVWXYZ';
-  const buf = new Uint8Array(4);
-  globalThis.crypto.getRandomValues(buf);
-  let out = '';
-  for (let i = 0; i < 4; i++) out += alphabet[(buf[i] as number) % alphabet.length];
-  return out;
-};
-
-const promptConfirmation = async (token: string): Promise<boolean> => {
+const promptConfirmation = async (): Promise<boolean> => {
   if (!process.stdin.isTTY) {
-    process.stderr.write(fillTemplate(confirmTtyRequiredTpl, { token }));
+    process.stderr.write(confirmTtyRequiredMsg);
     process.exit(2);
   }
   const rl = createInterface({ input: process.stdin, output: process.stderr });
   try {
-    const answer = await rl.question(fillTemplate(confirmPromptTpl, { token }));
-    return answer.trim() === token;
+    const answer = await rl.question(confirmPromptTpl);
+    return answer.trim() === 'confirm';
   } finally {
     rl.close();
   }
@@ -127,20 +115,10 @@ const main = async () => {
     process.exit(2);
   }
 
-  const token = randomToken();
-  process.stderr.write(
-    fillTemplate(destructiveHeaderTpl, { dialect: dialect.name, token }),
-  );
+  process.stderr.write(fillTemplate(destructiveHeaderTpl, { dialect: dialect.name }));
 
-  if (args.confirm !== null) {
-    if (args.confirm !== token) {
-      process.stderr.write(
-        fillTemplate(confirmMismatchTpl, { supplied: args.confirm, token }),
-      );
-      process.exit(2);
-    }
-  } else {
-    const ok = await promptConfirmation(token);
+  if (!args.confirm) {
+    const ok = await promptConfirmation();
     if (!ok) {
       process.stderr.write(confirmTokenMismatchMsg);
       process.exit(2);

package/{src → typescript/src}/bin/migrate-setup.ts

@@ -2,6 +2,7 @@
 // Idempotent migrate-setup — creates the migrates + migrate_logs tracking tables per dialect.
 
 import { missingProviderMsg, requireConnection, requireDialect, takeFlag } from '../cli.ts';
+import { createDatabase } from '../create-database.ts';
 import { fillTemplate, loadMessage } from '../infrastructure/message-templates.ts';
 import { loadHelp, Migrater } from '../index.ts';
 
@@ -17,11 +18,13 @@ const parseArgs = (argv: string[]) => {
     connection: string | null;
     migrationsPath: string | null;
     andUp: boolean;
+    createDatabase: boolean;
   } = {
     provider: null,
     connection: null,
     migrationsPath: null,
     andUp: false,
+    createDatabase: false,
   };
   const rest = argv.slice(2);
   for (let i = 0; i < rest.length; i++) {
@@ -34,6 +37,10 @@ const parseArgs = (argv: string[]) => {
       args.andUp = true;
       continue;
     }
+    if (a === '--create-database') {
+      args.createDatabase = true;
+      continue;
+    }
     let taken;
     if ((taken = takeFlag(rest, i, a, '--provider'))) {
       args.provider = taken.value;
@@ -65,6 +72,7 @@ const main = async () => {
   const connection = requireConnection(dialect, args.connection);
 
   const migrationsPath = args.migrationsPath ?? `./sql/${dialect.name}/migrations`;
+  if (args.createDatabase) await createDatabase(dialect.name, connection);
   const migrater = new Migrater(dialect);
   await migrater.setup({ connection, migrationsPath });
   process.stdout.write(

package/{src → typescript/src}/cli-spec.ts

@@ -20,6 +20,7 @@ export type CliCommand = {
 export type CliSpec = {
   command: string;
   providers: string[];
+  languages: string[];
   provider_aliases: Record<string, string>;
   aliases: Record<string, string>;
   env_var_list_separator: string;
@@ -30,8 +31,10 @@ export type CliSpec = {
 export const cliYamlPath = (): string => {
   const here = dirname(fileURLToPath(import.meta.url));
   const candidates = [
+    join(here, 'cli.yaml'),
     join(here, '..', 'cli.yaml'),
     join(here, '..', '..', 'cli.yaml'),
+    join(here, '..', '..', '..', 'cli.yaml'),
     join(process.cwd(), 'cli.yaml'),
   ];
   const found = candidates.find((candidate) => existsSync(candidate));
@@ -47,9 +50,15 @@ export const migrateCommand = (verb: MigrateVerb): string =>
   cliSpec.command.replace('{verb}', verb);
 
 const providers = cliSpec.providers.join('|');
+const languages = (cliSpec.languages ?? []).join('|');
 
 const argUsage = (arg: CliArg): string => {
-  const ph = arg.placeholder === 'providers' ? providers : arg.placeholder;
+  const ph =
+    arg.placeholder === 'providers'
+      ? providers
+      : arg.placeholder === 'languages'
+        ? languages
+        : arg.placeholder;
   const body = ph ? `${arg.flag} <${ph}>` : arg.flag;
   return arg.required ? body : `[${body}]`;
 };

package/typescript/src/create-database.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createDatabase } from './create-database.ts';
+import { defaultDialectFactory } from './infrastructure/default-factory.ts';
+
+describe('createDatabase', () => {
+  it('no-ops when the provider is not registered', async () => {
+    await createDatabase('dbase', 'x');
+  });
+
+  it('delegates to the dialect when it is installed', async () => {
+    const dialect = defaultDialectFactory.tryGet('sqlite') ?? defaultDialectFactory.all()[0];
+    if (!dialect) return;
+    const spy = vi.spyOn(dialect, 'createDatabaseIfMissing').mockResolvedValue();
+    await createDatabase(dialect.name, 'conn');
+    expect(spy).toHaveBeenCalledWith('conn');
+    spy.mockRestore();
+  });
+});

package/typescript/src/create-database.ts

@@ -0,0 +1,7 @@
+import { defaultDialectFactory } from './infrastructure/default-factory.ts';
+
+export const createDatabase = async (provider: string, connection: string): Promise<void> => {
+  const dialect = defaultDialectFactory.tryGet(provider);
+  if (!dialect) return;
+  await dialect.createDatabaseIfMissing(connection);
+};

package/{src → typescript/src}/datasource-migrate.ts

@@ -15,7 +15,7 @@ export type {
   MigrationSqlParam,
   SqliteRawDatabase,
 } from './migration-client.ts';
-export { applyMysqlDdlViaTextProtocol } from './dialects/mysql-dialect.ts';
+export { applyMysqlDdlViaTextProtocol } from './infrastructure/mysql-text-protocol.ts';
 
 /** One discovered migration: its up script and the rollback sibling when present. */
 export interface MigrationDescriptor {

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/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/{src → typescript/src}/infrastructure/templates-root.ts

@@ -6,6 +6,9 @@ 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');
   }

package/{src → typescript/src}/init-select.test.ts

@@ -23,4 +23,12 @@ describe('init dialect selection', () => {
       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/{src → typescript/src}/init-select.ts

@@ -7,7 +7,7 @@ import { cliSpec } from './cli-spec.ts';
 
 export type SelectedDialects = {
   names: string[];
-  packages: { name: string; version: string }[];
+  packages: { name: string }[];
   allDriverPackages: string[];
 };
 
@@ -36,16 +36,17 @@ export const resolveInitDialects = (raw: string[], all: boolean): string[] => {
   return cliSpec.providers.filter((name) => selected.has(name));
 };
 
+export type BundlePackage = {
+  name: string;
+  version?: string;
+};
+
 type BundleDialect = {
-  packages?: { name: string; version: string }[];
+  packages?: BundlePackage[];
 };
 
 type BundleDoc = {
-  languages?: {
-    typescript?: {
-      dialects?: Record<string, BundleDialect>;
-    };
-  };
+  languages?: Record<string, { dialects?: Record<string, BundleDialect> }>;
 };
 
 export const bundleYamlPath = (): string => {
@@ -62,9 +63,12 @@ export const bundleYamlPath = (): string => {
   return found;
 };
 
-export const loadSelectedPackages = async (dialects: string[]): Promise<SelectedDialects> => {
+export const loadSelectedPackages = async (
+  dialects: string[],
+  language = 'typescript',
+): Promise<SelectedDialects> => {
   const raw = parse(await readFile(bundleYamlPath(), 'utf8')) as BundleDoc;
-  const byName = raw.languages?.typescript?.dialects ?? {};
+  const byName = raw.languages?.[language]?.dialects ?? {};
   const allDriverPackages = [
     ...new Set(Object.values(byName).flatMap((d) => (d.packages ?? []).map((p) => p.name))),
   ];

package/typescript/tsconfig.build.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "types": ["node"],
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true,
+    "skipLibCheck": true,
+    "noCheck": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*.ts", "dialects/*/src/**/*.ts"],
+  "exclude": ["src/**/*.test.ts", "src/generate-help.ts", "dialects/**/*.test.ts"]
+}

package/dist/abstractions/migrater.d.ts

@@ -1,28 +0,0 @@
-export type SetupArg = {
-    connection: string;
-    migrationsPath: string;
-};
-export type UpArg = {
-    connection: string;
-    migrationsPath: string;
-    one?: boolean;
-};
-export type DownArg = {
-    connection: string;
-    migrationsPath: string;
-};
-export type CreateArg = {
-    name: string;
-    migrationsPath: string;
-};
-export type CreateResponse = {
-    upName: string;
-    downName: string;
-};
-export interface IMigrater {
-    readonly name: string;
-    setup(args: SetupArg): Promise<void>;
-    up(args: UpArg): Promise<string[]>;
-    down(args: DownArg): Promise<string | null>;
-    create(args: CreateArg): Promise<CreateResponse>;
-}

package/dist/abstractions/migrater.js

@@ -1 +0,0 @@
-export {};

package/dist/abstractions/sql-dialect-base.d.ts

@@ -1,16 +0,0 @@
-import type { SqlDialect } from '../sql.ts';
-import type { ISqlDialect } from './sql-dialect.ts';
-export declare abstract class SqlDialectBase implements ISqlDialect {
-    abstract readonly name: SqlDialect;
-    abstract readonly connectionEnvironmentVariables: readonly string[];
-    abstract readonly migratesDdl: string;
-    abstract readonly migrateLogsDdl: string;
-    readonly usesLastInsertRowid: boolean;
-    quoteIdent(ident: string): string;
-    nowExpr(): string;
-    limitClause(n: number): string;
-    translatePlaceholders(sql: string): string;
-    prerequisiteError(_connection: string): Promise<string | null>;
-    prepareSetup(_connection: string): Promise<void>;
-    abstract createClient(connection: string): Promise<import('../migration-client.ts').MigrationClient>;
-}

package/dist/abstractions/sql-dialect-base.js

@@ -1,19 +0,0 @@
-export class SqlDialectBase {
-    usesLastInsertRowid = false;
-    quoteIdent(ident) {
-        return `"${ident}"`;
-    }
-    nowExpr() {
-        return 'CURRENT_TIMESTAMP';
-    }
-    limitClause(n) {
-        return `LIMIT ${n}`;
-    }
-    translatePlaceholders(sql) {
-        return sql;
-    }
-    async prerequisiteError(_connection) {
-        return null;
-    }
-    async prepareSetup(_connection) { }
-}

package/dist/abstractions/sql-dialect-factory.d.ts

@@ -1,8 +0,0 @@
-import type { ISqlDialect } from './sql-dialect.ts';
-export declare class SqlDialectFactory {
-    private readonly byName;
-    constructor(dialects: readonly ISqlDialect[]);
-    tryGet(raw: string): ISqlDialect | undefined;
-    get(raw: string): ISqlDialect;
-    all(): readonly ISqlDialect[];
-}