@deterministic-code/migraters 0.0.0-stage → 0.0.2

package/dist/bin/migrate-create.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+// Scaffolds a new <NNNN>_<name>_{up,down}.sql pair in the migrations directory. Numbering is max(1-4-digit prefix in dir)+1; legacy timestamp prefixes are ignored.
+import { missingProviderMsg, requireDialect, takeFlag } from "../cli.js";
+import { isMigrationName } from "../create-sequence.js";
+import { fillTemplate, loadMessage } from "../infrastructure/message-templates.js";
+import { loadHelp, Migrater } from "../index.js";
+const [HELP_TEXT, unknownArgTpl, missingNameMsg, invalidNameTpl, createdTpl] = await Promise.all([
+    loadHelp('migrate-create'),
+    loadMessage('errors/unknown-arg'),
+    loadMessage('errors/missing-name'),
+    loadMessage('errors/invalid-name'),
+    loadMessage('status/created'),
+]);
+const parseArgs = (argv) => {
+    const args = { provider: null, name: null, migrationsPath: null };
+    const rest = argv.slice(2);
+    for (let i = 0; i < rest.length; i++) {
+        const a = rest[i];
+        if (a === '-h' || a === '--help') {
+            process.stderr.write(HELP_TEXT);
+            process.exit(0);
+        }
+        let taken;
+        if ((taken = takeFlag(rest, i, a, '--provider'))) {
+            args.provider = taken.value;
+            i = taken.next;
+        }
+        else if ((taken = takeFlag(rest, i, a, '--name'))) {
+            args.name = taken.value;
+            i = taken.next;
+        }
+        else if ((taken = takeFlag(rest, i, a, '--migrations-path')) ||
+            (taken = takeFlag(rest, i, a, '--migrate-path'))) {
+            args.migrationsPath = taken.value;
+            i = taken.next;
+        }
+        else {
+            process.stderr.write(fillTemplate(unknownArgTpl, { arg: a }));
+            process.exit(2);
+        }
+    }
+    return args;
+};
+const main = async () => {
+    const args = parseArgs(process.argv);
+    if (!args.provider) {
+        process.stderr.write(missingProviderMsg);
+        process.exit(2);
+    }
+    const dialect = requireDialect(args.provider);
+    if (!args.name) {
+        process.stderr.write(missingNameMsg);
+        process.exit(2);
+    }
+    if (!isMigrationName(args.name)) {
+        process.stderr.write(fillTemplate(invalidNameTpl, { name: args.name }));
+        process.exit(2);
+    }
+    const migrationsPath = args.migrationsPath ?? `./sql/${dialect.name}/migrations`;
+    const { upName, downName } = await new Migrater(dialect).create({
+        name: args.name,
+        migrationsPath,
+    });
+    process.stdout.write(fillTemplate(createdTpl, { file: upName }));
+    process.stdout.write(fillTemplate(createdTpl, { file: downName }));
+};
+main().catch((e) => {
+    const err = e;
+    process.stderr.write(`${err?.stack ?? err?.message ?? String(e)}\n`);
+    process.exit(1);
+});

package/dist/bin/migrate-down.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/migrate-down.js

@@ -0,0 +1,135 @@
+#!/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).
+import { resolve } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { missingProviderMsg, requireConnection, requireDialect, takeFlag } from "../cli.js";
+import { fillTemplate, loadMessage } from "../infrastructure/message-templates.js";
+import { loadHelp, Migrater } from "../index.js";
+const [HELP_TEXT, unknownArgTpl, destructiveHeaderTpl, confirmMismatchTpl, confirmTtyRequiredTpl, confirmPromptTpl, confirmTokenMismatchMsg, noRollbackMsg, rolledBackTpl,] = await Promise.all([
+    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'),
+    loadMessage('status/no-rollback'),
+    loadMessage('status/rolled-back'),
+]);
+const parseArgs = (argv) => {
+    const args = {
+        provider: null,
+        migratePath: null,
+        migrateRoot: null,
+        connection: null,
+        confirm: null,
+    };
+    const rest = argv.slice(2);
+    for (let i = 0; i < rest.length; i++) {
+        const a = rest[i];
+        if (a === '-h' || a === '--help') {
+            process.stderr.write(HELP_TEXT);
+            process.exit(0);
+        }
+        let taken;
+        if ((taken = takeFlag(rest, i, a, '--provider'))) {
+            args.provider = taken.value;
+            i = taken.next;
+        }
+        else if ((taken = takeFlag(rest, i, a, '--migrations-path')) ||
+            (taken = takeFlag(rest, i, a, '--migrate-path'))) {
+            args.migratePath = taken.value;
+            i = taken.next;
+        }
+        else if ((taken = takeFlag(rest, i, a, '--migrations-root')) ||
+            (taken = takeFlag(rest, i, a, '--migrate-root'))) {
+            args.migrateRoot = taken.value;
+            i = taken.next;
+        }
+        else if ((taken = takeFlag(rest, i, a, '--connection'))) {
+            args.connection = taken.value;
+            i = taken.next;
+        }
+        else if ((taken = takeFlag(rest, i, a, '--confirm'))) {
+            args.confirm = taken.value;
+            i = taken.next;
+        }
+        else {
+            process.stderr.write(fillTemplate(unknownArgTpl, { arg: a }));
+            process.exit(2);
+        }
+    }
+    return args;
+};
+const resolveMigratePath = (args, dialect) => {
+    if (args.migratePath)
+        return args.migratePath;
+    const root = args.migrateRoot ?? 'sql';
+    return `${root}/${dialect}/migrations`;
+};
+const randomToken = () => {
+    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] % alphabet.length];
+    return out;
+};
+const promptConfirmation = async (token) => {
+    if (!process.stdin.isTTY) {
+        process.stderr.write(fillTemplate(confirmTtyRequiredTpl, { token }));
+        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;
+    }
+    finally {
+        rl.close();
+    }
+};
+const main = async () => {
+    const args = parseArgs(process.argv);
+    if (!args.provider) {
+        process.stderr.write(missingProviderMsg);
+        process.exit(2);
+    }
+    const dialect = requireDialect(args.provider);
+    const connection = requireConnection(dialect, args.connection);
+    const missing = await dialect.prerequisiteError(connection);
+    if (missing !== null) {
+        process.stderr.write(`${missing}\n`);
+        process.exit(2);
+    }
+    const token = randomToken();
+    process.stderr.write(fillTemplate(destructiveHeaderTpl, { dialect: dialect.name, token }));
+    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 (!ok) {
+            process.stderr.write(confirmTokenMismatchMsg);
+            process.exit(2);
+        }
+    }
+    const migratePath = resolve(resolveMigratePath(args, dialect.name));
+    const name = await new Migrater(dialect).down({
+        connection,
+        migrationsPath: migratePath,
+    });
+    if (name == null)
+        process.stdout.write(noRollbackMsg);
+    else
+        process.stdout.write(fillTemplate(rolledBackTpl, { name }));
+};
+main().catch((e) => {
+    const err = e;
+    process.stderr.write(`${err?.stack ?? err?.message ?? String(e)}\n`);
+    process.exit(1);
+});

package/dist/bin/migrate-init.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/migrate-init.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { loadHelp } from "../help.js";
+import { loadSelectedPackages, resolveInitDialects } from "../init-select.js";
+const HELP_TEXT = await loadHelp('migrate-init');
+const takeFlag = (rest, i, arg, flag) => {
+    const eq = `${flag}=`;
+    if (arg === flag) {
+        const value = rest[i + 1];
+        if (value === undefined)
+            return undefined;
+        return { value, next: i + 1 };
+    }
+    if (arg.startsWith(eq))
+        return { value: arg.slice(eq.length), next: i };
+    return undefined;
+};
+const parseArgs = (argv) => {
+    const dialects = [];
+    let all = false;
+    const rest = argv.slice(2);
+    for (let i = 0; i < rest.length; i++) {
+        const a = rest[i];
+        if (a === '-h' || a === '--help') {
+            process.stderr.write(HELP_TEXT);
+            process.exit(0);
+        }
+        if (a === '--all') {
+            all = true;
+            continue;
+        }
+        const taken = takeFlag(rest, i, a, '--dialect');
+        if (taken) {
+            dialects.push(taken.value);
+            i = taken.next;
+            continue;
+        }
+        process.stderr.write(`unknown arg: ${a}\n`);
+        process.exit(2);
+    }
+    return { dialects, all };
+};
+const npmFlags = ['--no-audit', '--no-fund', '--loglevel=error'];
+const npm = (args) => {
+    const cmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const result = spawnSync(cmd, args, { stdio: 'inherit', cwd: process.cwd() });
+    if (result.status !== 0) {
+        process.exit(result.status ?? 1);
+    }
+};
+const main = async () => {
+    const args = parseArgs(process.argv);
+    let names;
+    try {
+        names = resolveInitDialects(args.dialects, args.all);
+    }
+    catch (e) {
+        const err = e;
+        process.stderr.write(`${err.message}\n`);
+        process.exit(2);
+    }
+    const selected = await loadSelectedPackages(names);
+    const specs = selected.packages.map((p) => `${p.name}@${p.version}`);
+    if (specs.length > 0) {
+        npm(['install', ...npmFlags, ...specs]);
+    }
+    const remove = selected.allDriverPackages.filter((name) => !selected.packages.some((p) => p.name === name));
+    if (remove.length > 0) {
+        npm(['uninstall', ...npmFlags, ...remove]);
+    }
+    process.stdout.write(`Enabled dialects: ${selected.names.join(', ')}\n`);
+};
+main().catch((e) => {
+    const err = e;
+    process.stderr.write(`${err?.stack ?? err?.message ?? String(e)}\n`);
+    process.exit(1);
+});

package/dist/bin/migrate-setup.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/migrate-setup.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+// Idempotent migrate-setup — creates the migrates + migrate_logs tracking tables per dialect.
+import { missingProviderMsg, requireConnection, requireDialect, takeFlag } from "../cli.js";
+import { fillTemplate, loadMessage } from "../infrastructure/message-templates.js";
+import { loadHelp, Migrater } from "../index.js";
+const [HELP_TEXT, unknownArgTpl, setupCompleteTpl] = await Promise.all([
+    loadHelp('migrate-setup'),
+    loadMessage('errors/unknown-arg'),
+    loadMessage('setup-complete'),
+]);
+const parseArgs = (argv) => {
+    const args = {
+        provider: null,
+        connection: null,
+        migrationsPath: null,
+        andUp: false,
+    };
+    const rest = argv.slice(2);
+    for (let i = 0; i < rest.length; i++) {
+        const a = rest[i];
+        if (a === '-h' || a === '--help') {
+            process.stderr.write(HELP_TEXT);
+            process.exit(0);
+        }
+        if (a === '--and-up') {
+            args.andUp = true;
+            continue;
+        }
+        let taken;
+        if ((taken = takeFlag(rest, i, a, '--provider'))) {
+            args.provider = taken.value;
+            i = taken.next;
+        }
+        else if ((taken = takeFlag(rest, i, a, '--connection'))) {
+            args.connection = taken.value;
+            i = taken.next;
+        }
+        else if ((taken = takeFlag(rest, i, a, '--migrations-path')) ||
+            (taken = takeFlag(rest, i, a, '--migrate-path'))) {
+            args.migrationsPath = taken.value;
+            i = taken.next;
+        }
+        else {
+            process.stderr.write(fillTemplate(unknownArgTpl, { arg: a }));
+            process.exit(2);
+        }
+    }
+    return args;
+};
+const main = async () => {
+    const args = parseArgs(process.argv);
+    if (!args.provider) {
+        process.stderr.write(missingProviderMsg);
+        process.exit(2);
+    }
+    const dialect = requireDialect(args.provider);
+    const connection = requireConnection(dialect, args.connection);
+    const migrationsPath = args.migrationsPath ?? `./sql/${dialect.name}/migrations`;
+    const migrater = new Migrater(dialect);
+    await migrater.setup({ connection, migrationsPath });
+    process.stdout.write(fillTemplate(setupCompleteTpl, {
+        dialect: dialect.name,
+        migrationsPath,
+        createExample: `  migrate-create --provider ${dialect.name} --name add_users`,
+        upExample: `  migrate-up --provider ${dialect.name} --connection ${connection}`,
+    }));
+    if (args.andUp) {
+        const names = await migrater.up({ connection, migrationsPath });
+        const [noPendingMsg, noMorePendingMsg, appliedTpl] = await Promise.all([
+            loadMessage('status/no-pending'),
+            loadMessage('status/no-more-pending'),
+            loadMessage('status/applied'),
+        ]);
+        if (names.length === 0)
+            process.stdout.write(noPendingMsg);
+        else {
+            for (const name of names)
+                process.stdout.write(fillTemplate(appliedTpl, { name }));
+            process.stdout.write(noMorePendingMsg);
+        }
+    }
+};
+main().catch((e) => {
+    const err = e;
+    process.stderr.write(`${err?.stack ?? err?.message ?? String(e)}\n`);
+    process.exit(1);
+});

package/dist/bin/migrate-up.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/migrate-up.js

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

package/dist/cli-contract.d.ts

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

package/dist/cli-contract.js

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

package/dist/cli-spec.d.ts

@@ -0,0 +1,24 @@
+export type MigrateVerb = 'init' | 'setup' | 'up' | 'down' | 'create';
+export type CliArg = {
+    flag: string;
+    placeholder?: string;
+    required: boolean;
+};
+export type CliCommand = {
+    verb: MigrateVerb;
+    args: CliArg[];
+};
+export type CliSpec = {
+    command: string;
+    providers: string[];
+    provider_aliases: Record<string, string>;
+    aliases: Record<string, string>;
+    env_var_list_separator: string;
+    connection_environment: Record<string, string[]>;
+    commands: CliCommand[];
+};
+export declare const cliYamlPath: () => string;
+export declare const cliSpec: CliSpec;
+export declare const migrateCommand: (verb: MigrateVerb) => string;
+export declare const usageLine: (verb: MigrateVerb) => string;
+export declare const programUsageText: () => string;

package/dist/cli-spec.js

@@ -0,0 +1,33 @@
+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';
+export const cliYamlPath = () => {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        join(here, '..', 'cli.yaml'),
+        join(here, '..', '..', 'cli.yaml'),
+        join(process.cwd(), 'cli.yaml'),
+    ];
+    const found = candidates.find((candidate) => existsSync(candidate));
+    if (!found) {
+        throw new Error('cli.yaml not found');
+    }
+    return found;
+};
+export const cliSpec = parse(await readFile(cliYamlPath(), 'utf8'));
+export const migrateCommand = (verb) => cliSpec.command.replace('{verb}', verb);
+const providers = cliSpec.providers.join('|');
+const argUsage = (arg) => {
+    const ph = arg.placeholder === 'providers' ? providers : arg.placeholder;
+    const body = ph ? `${arg.flag} <${ph}>` : arg.flag;
+    return arg.required ? body : `[${body}]`;
+};
+export const usageLine = (verb) => {
+    const command = cliSpec.commands.find((c) => c.verb === verb);
+    if (!command)
+        throw new Error(`cli.yaml: missing command ${verb}`);
+    return `Usage: ${migrateCommand(verb)} ${command.args.map(argUsage).join(' ')}`;
+};
+export const programUsageText = () => `${cliSpec.commands.map((c) => usageLine(c.verb)).join('\n')}\n`;

package/dist/cli.d.ts

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

package/dist/cli.js

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

package/dist/create-sequence.d.ts

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

package/dist/create-sequence.js

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

package/dist/datasource-migrate.d.ts

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