@deterministic-code/migraters 0.0.0-stage → 0.0.1

package/dist/dialects/oracle-dialect.d.ts

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

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

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

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

package/dist/dialects/sqlite-dialect.d.ts

@@ -0,0 +1,13 @@
+import type { MigrationClient } from '../migration-client.ts';
+import { SqlDialectBase } from '../abstractions/sql-dialect-base.ts';
+export declare const sqliteFilesystemPath: (connection: string) => string | null;
+export declare class SqliteDialect extends SqlDialectBase {
+    readonly name: "sqlite";
+    readonly connectionEnvironmentVariables: readonly ["SQLITE_PATH", "DB_PATH"];
+    readonly migratesDdl: string;
+    readonly migrateLogsDdl: string;
+    readonly usesLastInsertRowid = true;
+    prerequisiteError(connection: string): Promise<string | null>;
+    prepareSetup(connection: string): Promise<void>;
+    createClient(connection: string): Promise<MigrationClient>;
+}

package/dist/dialects/sqlite-dialect.js

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

package/dist/dialects/sqlserver-dialect.d.ts

@@ -0,0 +1,12 @@
+import type { MigrationClient } from '../migration-client.ts';
+import { SqlDialectBase } from '../abstractions/sql-dialect-base.ts';
+export declare class SqlServerDialect extends SqlDialectBase {
+    readonly name: "sqlserver";
+    readonly connectionEnvironmentVariables: readonly ["MSSQL_URL", "DATABASE_URL"];
+    readonly migratesDdl: string;
+    readonly migrateLogsDdl: string;
+    quoteIdent(ident: string): string;
+    nowExpr(): string;
+    limitClause(n: number): string;
+    createClient(connection: string): Promise<MigrationClient>;
+}

package/dist/dialects/sqlserver-dialect.js

@@ -0,0 +1,73 @@
+import { interopDefault } from "../infrastructure/interop-default.js";
+import { readSqlTemplate } from "../infrastructure/sql-templates.js";
+import { SqlDialectBase } from "../abstractions/sql-dialect-base.js";
+const [migratesDdl, migrateLogsDdl] = await Promise.all([
+    readSqlTemplate('sqlserver', 'migrates'),
+    readSqlTemplate('sqlserver', 'migrate_logs'),
+]);
+const bindMssql = (req, sql, params) => {
+    let n = 0;
+    return sql.replace(/\?/g, () => {
+        const name = `p${n}`;
+        req.input(name, params[n]);
+        n++;
+        return `@${name}`;
+    });
+};
+export class SqlServerDialect extends SqlDialectBase {
+    name = 'sqlserver';
+    connectionEnvironmentVariables = ['MSSQL_URL', 'DATABASE_URL'];
+    migratesDdl = migratesDdl;
+    migrateLogsDdl = migrateLogsDdl;
+    quoteIdent(ident) {
+        return `[${ident}]`;
+    }
+    nowExpr() {
+        return 'SYSUTCDATETIME()';
+    }
+    limitClause(n) {
+        return `OFFSET 0 ROWS FETCH NEXT ${n} ROWS ONLY`;
+    }
+    async createClient(connection) {
+        const mssql = interopDefault(await import('mssql'));
+        const pool = await mssql.connect(connection);
+        return {
+            dialect: 'sqlserver',
+            async exec(sql) {
+                await pool.request().batch(sql);
+            },
+            async query(sql, params = []) {
+                const req = pool.request();
+                const translated = bindMssql(req, sql, params);
+                const r = await req.query(translated);
+                return r.recordset ?? [];
+            },
+            async run(sql, params = []) {
+                const req = pool.request();
+                const translated = bindMssql(req, sql, params);
+                await req.query(translated);
+            },
+            async transaction(fn) {
+                const tx = pool.transaction();
+                await tx.begin();
+                try {
+                    const r = await fn();
+                    await tx.commit();
+                    return r;
+                }
+                catch (e) {
+                    try {
+                        await tx.rollback();
+                    }
+                    catch (rollbackErr) {
+                        console.warn('sqlserver rollback failed after transaction error; original error rethrown', rollbackErr);
+                    }
+                    throw e;
+                }
+            },
+            async close() {
+                await pool.close();
+            },
+        };
+    }
+}

package/dist/help.d.ts

@@ -0,0 +1,2 @@
+export declare const loadHelp: (command: string) => Promise<string>;
+export declare const loadProgramUsage: () => Promise<string>;

package/dist/help.js

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

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './datasource-migrate.ts';
+export type { CreateArg, CreateResponse, DownArg, IMigrater, SetupArg, UpArg, } from './abstractions/migrater.ts';
+export { getMigrater, Migrater } from './migrater.ts';
+export { fillHelpTemplate, migrateCommand, verbFromCommand, type MigrateVerb, } from './cli-contract.ts';
+export { loadHelp, loadProgramUsage } from './help.ts';
+export { fillTemplate, loadMessage, loadScaffold, } from './infrastructure/message-templates.ts';
+export { normalizeDialect, pathExists, type SqlDialect } from './sql.ts';

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./datasource-migrate.js";
+export { getMigrater, Migrater } from "./migrater.js";
+export { fillHelpTemplate, migrateCommand, verbFromCommand, } from "./cli-contract.js";
+export { loadHelp, loadProgramUsage } from "./help.js";
+export { fillTemplate, loadMessage, loadScaffold, } from "./infrastructure/message-templates.js";
+export { normalizeDialect, pathExists } from "./sql.js";

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

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

package/dist/infrastructure/connection-resolver.js

@@ -0,0 +1,19 @@
+export class ConnectionResolver {
+    env;
+    constructor(env = process.env) {
+        this.env = env;
+    }
+    fromEnvironment(dialect) {
+        for (const name of dialect.connectionEnvironmentVariables) {
+            const value = this.env[name];
+            if (value)
+                return value;
+        }
+        return null;
+    }
+    resolve(dialect, fromFlag) {
+        if (fromFlag)
+            return fromFlag;
+        return this.fromEnvironment(dialect);
+    }
+}

package/dist/infrastructure/default-factory.d.ts

@@ -0,0 +1,4 @@
+import { SqlDialectFactory } from '../abstractions/sql-dialect-factory.ts';
+import { ConnectionResolver } from './connection-resolver.ts';
+export declare const defaultDialectFactory: SqlDialectFactory;
+export declare const connectionResolver: ConnectionResolver;

package/dist/infrastructure/default-factory.js

@@ -0,0 +1,15 @@
+import { SqlDialectFactory } from "../abstractions/sql-dialect-factory.js";
+import { MysqlDialect } from "../dialects/mysql-dialect.js";
+import { OracleDialect } from "../dialects/oracle-dialect.js";
+import { PostgresDialect } from "../dialects/postgres-dialect.js";
+import { SqliteDialect } from "../dialects/sqlite-dialect.js";
+import { SqlServerDialect } from "../dialects/sqlserver-dialect.js";
+import { ConnectionResolver } from "./connection-resolver.js";
+export const defaultDialectFactory = new SqlDialectFactory([
+    new SqliteDialect(),
+    new PostgresDialect(),
+    new MysqlDialect(),
+    new SqlServerDialect(),
+    new OracleDialect(),
+]);
+export const connectionResolver = new ConnectionResolver();

package/dist/infrastructure/interop-default.d.ts

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

package/dist/infrastructure/interop-default.js

@@ -0,0 +1 @@
+export const interopDefault = (mod) => (mod.default ?? mod);

package/dist/infrastructure/message-templates.d.ts

@@ -0,0 +1,3 @@
+export declare const fillTemplate: (text: string, vars: Record<string, string>) => string;
+export declare const loadMessage: (relativePath: string, vars?: Record<string, string>) => Promise<string>;
+export declare const loadScaffold: (name: "up" | "down", vars: Record<string, string>) => Promise<string>;

package/dist/infrastructure/message-templates.js

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

package/dist/infrastructure/split-on-go.d.ts

@@ -0,0 +1,2 @@
+/** Split migration SQL on whole-line GO batch separators. */
+export declare function splitOnGo(text: string): string[];

package/dist/infrastructure/split-on-go.js

@@ -0,0 +1,20 @@
+const GO_LINE = /^\s*GO\s*$/i;
+/** Split migration SQL on whole-line GO batch separators. */
+export function splitOnGo(text) {
+    const batches = [];
+    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/dist/infrastructure/sql-templates.d.ts

@@ -0,0 +1,2 @@
+import type { SqlDialect } from '../sql.ts';
+export declare const readSqlTemplate: (dialect: SqlDialect, name: "migrates" | "migrate_logs") => Promise<string>;

package/dist/infrastructure/sql-templates.js

@@ -0,0 +1,4 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { templatesRoot } from "./templates-root.js";
+export const readSqlTemplate = async (dialect, name) => (await readFile(join(templatesRoot(), 'sql', dialect, `${name}.sql`), 'utf8')).trim();

package/dist/infrastructure/templates-root.d.ts

@@ -0,0 +1,2 @@
+/** Repo `shared/templates`; after build, `dist/templates` (copied from shared). */
+export declare const templatesRoot: () => string;

package/dist/infrastructure/templates-root.js

@@ -0,0 +1,11 @@
+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 = () => {
+    const normalized = HERE.replaceAll('\\', '/');
+    if (normalized.endsWith('/dist/infrastructure')) {
+        return join(HERE, '..', 'templates');
+    }
+    return join(HERE, '..', '..', '..', 'shared', 'templates');
+};

package/dist/init-select.d.ts

@@ -0,0 +1,12 @@
+export type SelectedDialects = {
+    names: string[];
+    packages: {
+        name: string;
+        version: string;
+    }[];
+    allDriverPackages: string[];
+};
+export declare const normalizeInitProvider: (raw: string) => string | undefined;
+export declare const resolveInitDialects: (raw: string[], all: boolean) => string[];
+export declare const bundleYamlPath: () => string;
+export declare const loadSelectedPackages: (dialects: string[]) => Promise<SelectedDialects>;

package/dist/init-select.js

@@ -0,0 +1,52 @@
+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.js";
+const stripKey = (raw) => raw.replace(/[\s_-]/g, '').toLowerCase();
+export const normalizeInitProvider = (raw) => {
+    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, all) => {
+    if (all)
+        return [...cliSpec.providers];
+    if (raw.length === 0) {
+        throw new Error('pass --dialect <provider> at least once, or --all');
+    }
+    const selected = new Set();
+    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 const bundleYamlPath = () => {
+    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) => {
+    const raw = parse(await readFile(bundleYamlPath(), 'utf8'));
+    const byName = raw.languages?.typescript?.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/dist/migrater.d.ts

@@ -0,0 +1,12 @@
+import type { CreateArg, CreateResponse, DownArg, IMigrater, SetupArg, UpArg } from './abstractions/migrater.ts';
+import type { ISqlDialect } from './abstractions/sql-dialect.ts';
+export declare class Migrater implements IMigrater {
+    private readonly dialect;
+    constructor(dialect: ISqlDialect);
+    get name(): string;
+    setup({ connection, migrationsPath }: SetupArg): Promise<void>;
+    up({ connection, migrationsPath, one }: UpArg): Promise<string[]>;
+    down({ connection, migrationsPath }: DownArg): Promise<string | null>;
+    create({ name, migrationsPath }: CreateArg): Promise<CreateResponse>;
+}
+export declare const getMigrater: (provider: string) => IMigrater;