@deterministic-code/migraters 0.0.2 → 0.0.4

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

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

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

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

@@ -1,73 +0,0 @@
-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.js

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

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

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

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

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

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

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

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

package/dist/infrastructure/interop-default.js

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

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

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

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

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

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

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

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

package/dist/infrastructure/sql-templates.js

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

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

package/dist/infrastructure/templates-root.js

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

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

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

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

package/dist/migrater.js

@@ -1,84 +0,0 @@
-import { mkdir, readdir, writeFile } from 'node:fs/promises';
-import { isMigrationName, nextSequence, pad4 } from "./create-sequence.js";
-import { applyOneDown, applyOneUp, discoverMigrations } from "./datasource-migrate.js";
-import { defaultDialectFactory } from "./infrastructure/default-factory.js";
-import { fillTemplate, loadMessage, loadScaffold } from "./infrastructure/message-templates.js";
-const invalidNameTpl = await loadMessage('errors/invalid-name');
-export class Migrater {
-    dialect;
-    constructor(dialect) {
-        this.dialect = dialect;
-    }
-    get name() {
-        return this.dialect.name;
-    }
-    async setup({ connection, migrationsPath }) {
-        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 }) {
-        const client = await this.dialect.createClient(connection);
-        try {
-            const migrations = await discoverMigrations({
-                migratePath: migrationsPath,
-                dialect: this.dialect.name,
-            });
-            const applied = [];
-            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 }) {
-        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 }) {
-        if (!isMigrationName(name)) {
-            throw new Error(fillTemplate(invalidNameTpl, { name }));
-        }
-        await mkdir(migrationsPath, { recursive: true });
-        let entries = [];
-        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) => new Migrater(defaultDialectFactory.get(provider));

package/dist/migration-client.js

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

package/dist/path-exists.d.ts

@@ -1 +0,0 @@
-export declare const pathExists: (p: string) => Promise<boolean>;

package/dist/path-exists.js

@@ -1,10 +0,0 @@
-import { access } from 'node:fs/promises';
-export const pathExists = async (p) => {
-    try {
-        await access(p);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};

package/dist/sql.d.ts

@@ -1,3 +0,0 @@
-export type SqlDialect = 'sqlite' | 'mysql' | 'postgres' | 'sqlserver' | 'oracle';
-export declare const normalizeDialect: (raw: string | null | undefined) => SqlDialect | null;
-export { pathExists } from './path-exists.ts';

package/dist/sql.js

@@ -1,15 +0,0 @@
-import { cliSpec } from "./cli-spec.js";
-const stripKey = (raw) => raw.toLowerCase().replace(/[\s_\-]/g, '');
-export const normalizeDialect = (raw) => {
-    if (!raw)
-        return null;
-    const key = stripKey(raw);
-    if (cliSpec.providers.includes(key))
-        return key;
-    for (const [alias, canonical] of Object.entries(cliSpec.provider_aliases ?? {})) {
-        if (stripKey(alias) === key)
-            return canonical;
-    }
-    return null;
-};
-export { pathExists } from "./path-exists.js";

package/dist/templates/help/init.txt

@@ -1,13 +0,0 @@
-{{usage}}
-
-Selects the dialects this tree will compile and install. Repeat --dialect
-once per provider. Re-running replaces the previous set. --all restores
-every dialect. Does not take --connection.
-
-  --dialect  Dialect to enable. Repeat for each dialect. Aliases from this file apply.
-  --all      Enable every dialect. Restores the committed full-provider set.
-
-Examples:
-  {{command}} --dialect sqlite --dialect postgres
-  {{command}} --dialect oracle
-  {{command}} --all

package/dist/templates/messages/down/confirm-prompt.txt

@@ -1 +0,0 @@
-Type {{token}} to confirm rollback: 

package/dist/templates/messages/down/confirm-token-mismatch.txt

@@ -1 +0,0 @@
-Confirmation token did not match — aborting.

package/dist/templates/messages/down/confirm-tty-required.txt

@@ -1 +0,0 @@
-migrate-down requires interactive confirmation when stdin is not a TTY — pass --confirm {{token}} (this exact token, printed above) to proceed.