mysqlsyncr 1.1.12 → 1.2.1

package/src/prompt.js

@@ -0,0 +1,109 @@
+import readline from 'readline';
+import path from 'path';
+import { isInsidePackage, packageRoot, templateFolderProblem } from './paths.js';
+
+const COMMANDS = [
+    { name: 'compare', description: 'Compare the database structure with JSON dumps (dry run)' },
+    { name: 'update', description: 'Update the database structure based on JSON dumps' },
+    { name: 'dump', description: 'Dump the database structure to files' },
+    { name: 'ui', description: 'Open the UI' },
+    { name: 'rebuild', description: "Rebuild the dump's JSON from each table's CREATE TABLE" }
+];
+
+// Commands that connect to MySQL from the command line (the UI asks for its own connection)
+export const DATABASE_COMMANDS = ['compare', 'update', 'dump'];
+
+// Commands that read an existing template, so its folder must already hold one
+const TEMPLATE_COMMANDS = ['compare', 'update', 'rebuild'];
+
+const PASSWORD_LABEL = 'MySQL password (typing is hidden, Enter for none)';
+
+const createPrompter = ({ input = process.stdin, output = process.stdout } = {}) => {
+    const rl = readline.createInterface({ input, output, terminal: true });
+
+    // Lets a password be typed without echoing it
+    let muted = false;
+    rl._writeToOutput = (text) => {
+        if (!muted) rl.output.write(text);
+    };
+
+    const question = (text) => new Promise(resolve => rl.question(text, resolve));
+    const ask = async (label, defaultValue) => {
+        const hint = defaultValue !== undefined && defaultValue !== null && defaultValue !== '' ? ` (${defaultValue})` : '';
+        const answer = (await question(`${label}${hint}: `)).trim();
+        return answer === '' ? defaultValue : answer;
+    };
+    const askHidden = async (label) => {
+        rl.output.write(`${label}: `);
+        muted = true;
+        const answer = await question('');
+        muted = false;
+        rl.output.write('\n');
+        return answer;
+    };
+    const confirm = async (label) => /^y(es)?$/i.test(await ask(`${label} (y/N)`));
+    const say = (text) => output.write(`${text}\n`);
+    return { ask, askHidden, confirm, say, close: () => rl.close() };
+}
+
+/**
+ * Ask for the MySQL password when a command was given without --password.
+ */
+export const promptForPassword = async (argv, streams) => {
+    const prompter = createPrompter(streams);
+    try {
+        return await prompter.askHidden(`${PASSWORD_LABEL} for ${argv.user}@${argv.host}`);
+    } finally {
+        prompter.close();
+    }
+}
+
+/**
+ * Ask for the command and its options when mysqlsyncr is run with no arguments.
+ * Fills in argv and returns the chosen command, or null if the user cancels.
+ */
+export const promptForOptions = async (argv, streams) => {
+    const { ask, askHidden, confirm, say, close } = createPrompter(streams);
+
+    try {
+        say('No command given. Choose one:');
+        COMMANDS.forEach((command, i) => say(`  ${i + 1}) ${command.name.padEnd(8)} ${command.description}`));
+        const choice = String(await ask('Command', '1'));
+        const command = COMMANDS[Number(choice) - 1]?.name ?? COMMANDS.find(c => c.name === choice.toLowerCase())?.name;
+        if (!command) {
+            console.error(`Unknown command: ${choice}`);
+            return null;
+        }
+
+        if (DATABASE_COMMANDS.includes(command)) {
+            argv.host = await ask('MySQL host', argv.host);
+            argv.port = Number(await ask('MySQL port', argv.port));
+            argv.user = await ask('MySQL user', argv.user);
+            argv.password = await askHidden(PASSWORD_LABEL);
+            argv.database = (await ask('Database (blank for all)', argv.database ?? '')) || null;
+        }
+        if (command !== 'ui') {
+            argv.output = await ask(command === 'dump' ? 'Folder to dump to' : 'Template folder', argv.output);
+            for (;;) {
+                let problem = null;
+                if (!argv.output) problem = '';
+                else if (isInsidePackage(argv.output)) problem = `That folder is inside the mysqlsyncr package folder (${packageRoot}). Choose one outside it.`;
+                else if (TEMPLATE_COMMANDS.includes(command)) problem = templateFolderProblem(argv.output);
+                if (problem === null) break;
+                if (problem) say(problem);
+                argv.output = await ask('Folder');
+            }
+            if (command === 'dump') say(`Dumping to ${path.resolve(argv.output)}`);
+        }
+        if (command === 'rebuild') {
+            argv.write = await confirm('Write the rebuilt files? No lists the changes only');
+        }
+        if (command === 'update' && !await confirm(`This will change the structure of ${argv.database ?? 'every database'} on ${argv.host}. Continue?`)) {
+            say('Cancelled.');
+            return null;
+        }
+        return command;
+    } finally {
+        close();
+    }
+}

package/src/rebuild.js

@@ -0,0 +1,106 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { parseCreateTableSQL } from './parsers.js';
+import { normalizedDefault } from './differences.js';
+import { loadSyncOptions, getTableOptions, applyAutoIncrementOption } from './options.js';
+import { assertOutsidePackage } from './paths.js';
+import { splitSqlFile } from './templateDrift.js';
+
+const describeColumn = (col) => JSON.stringify({ Type: col.Type, NotNull: !!col.NotNull, Default: normalizedDefault(col) });
+const describeIndexes = (indexes) => (indexes || [])
+    .map(i => `${i.Name}${i.Primary || i.Name === 'PRIMARY' ? ' PRIMARY' : ''}${i.Unique ? ' UNIQUE' : ''} (${i.ColumnName.join(', ')})`)
+    .sort();
+
+// What would change in one table's JSON if it were rebuilt from its createSQL
+const tableChanges = (table, rebuilt, createSQL) => {
+    const changes = [];
+    if (createSQL !== table.createSQL) {
+        changes.push('createSQL: AUTO_INCREMENT counter changed by the autoIncrement option');
+    }
+    for (const col of table.columns || []) {
+        const rebuiltCol = rebuilt.columns.find(c => c.Field === col.Field);
+        if (!rebuiltCol) {
+            changes.push(`column ${col.Field}: in the JSON but not in createSQL (removed)`);
+        } else if (describeColumn(col) !== describeColumn(rebuiltCol)) {
+            changes.push(`column ${col.Field}: JSON ${describeColumn(col)} -> createSQL ${describeColumn(rebuiltCol)}`);
+        }
+    }
+    for (const col of rebuilt.columns) {
+        if (!(table.columns || []).some(c => c.Field === col.Field)) {
+            changes.push(`column ${col.Field}: in createSQL but not in the JSON (added)`);
+        }
+    }
+    const before = describeIndexes(table.indexes);
+    const after = describeIndexes(rebuilt.indexes);
+    for (const index of before.filter(i => !after.includes(i))) changes.push(`index ${index}: removed`);
+    for (const index of after.filter(i => !before.includes(i))) changes.push(`index ${index}: added`);
+    return changes;
+}
+
+/**
+ * Rebuild each table's columns/indexes/constraints in a template from its
+ * createSQL with the current parser, applying the autoIncrement option to the
+ * createSQL. Returns { changes, notes }: changes is { 'db.table': [change, ...] }
+ * for tables that would change, notes is { 'db.table': note } for things to check
+ * by hand. Only writes the files when write is true.
+ */
+export const rebuildTemplate = async (dir, { write = false } = {}) => {
+    if (write) assertOutsidePackage(dir);
+    const syncOptions = await loadSyncOptions(dir);
+    const report = {};
+    const notes = {};
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries.filter(e => e.isDirectory())) {
+        const database = entry.name;
+        const jsonPath = path.join(dir, database, `${database}.json`);
+        let structure;
+        try {
+            structure = JSON.parse(await fs.readFile(jsonPath, 'utf-8'));
+        } catch (err) {
+            if (err.code === 'ENOENT') continue;
+            throw new Error(`Could not read ${jsonPath}: ${err.message}`);
+        }
+
+        let changed = false;
+        for (const [tableName, table] of Object.entries(structure.tables || {})) {
+            if (!table.createSQL) continue;
+            const createSQL = applyAutoIncrementOption(table.createSQL, getTableOptions(syncOptions, database, tableName).autoIncrement);
+            const rebuilt = parseCreateTableSQL(createSQL);
+            const changes = tableChanges(table, rebuilt, createSQL);
+
+            // tables/<table>.sql should match createSQL, but it can hold notes or edits made
+            // by hand, so only the AUTO_INCREMENT option is applied to it; any other
+            // difference is reported, never overwritten
+            const sqlPath = path.join(dir, database, 'tables', `${tableName}.sql`);
+            const sqlFile = await fs.readFile(sqlPath, 'utf-8').catch(() => null);
+            const fixedSqlFile = sqlFile === null ? null : applyAutoIncrementOption(sqlFile, getTableOptions(syncOptions, database, tableName).autoIncrement);
+            const sqlCounterChanged = sqlFile !== null && fixedSqlFile !== sqlFile;
+            if (sqlCounterChanged) changes.push(`tables/${tableName}.sql: AUTO_INCREMENT counter changed by the autoIncrement option`);
+            // Notes written after the statement don't count
+            const sameSQL = (a, b) => a.replace(/\r\n/g, '\n').replace(/;?\s*$/, '') === b.replace(/\r\n/g, '\n').replace(/;?\s*$/, '');
+            const sqlFileDrifted = fixedSqlFile !== null && !sameSQL(splitSqlFile(fixedSqlFile).statement, createSQL);
+            if (changes.length === 0 && !sqlFileDrifted) continue;
+
+            if (changes.length > 0) report[`${database}.${tableName}`] = changes;
+            if (sqlFileDrifted) {
+                notes[`${database}.${tableName}`] = `tables/${tableName}.sql differs from the createSQL in ${database}.json (left as is; compare uses the JSON). Pick which to keep in the UI.`;
+            }
+            if (sqlCounterChanged && write) {
+                await fs.writeFile(sqlPath, fixedSqlFile, 'utf-8');
+            }
+            if (changes.length === 0 || changes.every(change => change.startsWith('tables/'))) continue; // the JSON is already right
+
+            changed = true;
+            table.columns = rebuilt.columns;
+            table.indexes = rebuilt.indexes;
+            table.constraints = rebuilt.constraints;
+            table.createSQL = createSQL;
+        }
+
+        if (changed && write) {
+            await fs.writeFile(jsonPath, JSON.stringify(structure, null, 4), 'utf-8');
+        }
+    }
+    return { changes: report, notes };
+}

package/src/rows.js

@@ -0,0 +1,46 @@
+const primaryKeyColumns = (table) => table?.indexes
+    ?.find(i => i.Primary || i.Name === 'PRIMARY')
+    ?.ColumnName.map(col => col.replace(/\(\d+\)$/, ''));
+
+/**
+ * Seed rows from the sync options that aren't in the database yet, as
+ * missing_row differences. A row counts as present when a row with the same
+ * rowKey values exists, whatever its other columns hold. Rows for a table that
+ * doesn't exist yet are all missing; they're applied after the table is created.
+ */
+export const findMissingRows = async (connection, database, expected, current, syncOptions) => {
+    const differences = [];
+    for (const [tableName, tableOptions] of Object.entries(syncOptions?.databases?.[database] || {})) {
+        if (!tableOptions?.rows?.length) continue;
+
+        const key = tableOptions.rowKey ?? primaryKeyColumns(expected.tables?.[tableName]) ?? primaryKeyColumns(current.tables?.[tableName]);
+        if (!key) {
+            throw new Error(`${database}.${tableName}: rows need a rowKey because the table has no primary key`);
+        }
+        const tableExists = !!current.tables?.[tableName];
+
+        for (const row of tableOptions.rows) {
+            const missingKeyColumns = key.filter(col => !(col in row));
+            if (missingKeyColumns.length > 0) {
+                throw new Error(`${database}.${tableName}: a row is missing rowKey column(s) ${missingKeyColumns.join(', ')}: ${JSON.stringify(row)}`);
+            }
+            const rowKey = Object.fromEntries(key.map(col => [col, row[col]]));
+
+            if (tableExists) {
+                const where = key.map(col => row[col] === null ? `\`${col}\` IS NULL` : `\`${col}\` = ?`).join(' AND ');
+                const values = key.filter(col => row[col] !== null).map(col => row[col]);
+                let found;
+                try {
+                    found = await connection.query(`SELECT 1 FROM \`${database}\`.\`${tableName}\` WHERE ${where} LIMIT 1`, values);
+                } catch (err) {
+                    // e.g. a key column the table doesn't have yet; checked again once the structure is fixed
+                    console.error(`Could not check seed rows for ${database}.${tableName}: ${err.message}`);
+                    break;
+                }
+                if (found.length > 0) continue;
+            }
+            differences.push({ type: 'missing_row', tableName, key: rowKey, row });
+        }
+    }
+    return differences;
+}

package/src/socketServer.js

@@ -2,17 +2,17 @@ import express from 'express';
 import http from 'http';
 import { dumpAllDatabases, getDatabasesFromExistingDumps } from './dump.js'; // Import necessary functions
 import { compareAllDatabases } from './compare.js';
-import { DBStructureChecker } from './index.js'; // Import your DBStructureChecker class
+import { DBStructureChecker } from './DBStructureChecker.js';
 import { applyDifferences } from './apply.js';
+import { packageRoot, assertOutsidePackage } from './paths.js';
+import { acceptCurrentIntoTemplate } from './acceptCurrent.js';
+import { getVersionInfo } from './versions.js';
+import { findTemplateDrift, resolveTemplateDrift } from './templateDrift.js';
 import cors from 'cors';
 import { join } from 'path';
 import { readdir, mkdir } from 'fs/promises';
 import { resolve } from 'path';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
 
 const setConfig = (config, argv) => {
     if(!config.host && argv.host){
@@ -33,21 +33,6 @@ const setConfig = (config, argv) => {
     return config;
 }
 
-// Create a function to get the package root directory that works in both ESM and CJS
-const getPackageRoot = () => {
-    if (typeof __dirname !== 'undefined') {
-        // CommonJS
-        return join(__dirname, '..');
-    } else {
-        // ESM
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = dirname(__filename);
-        return join(__dirname, '..');
-    }
-};
-
-// Use the function to get the root path
-const packageRoot = getPackageRoot();
 
 export const startApiServer = (port, argv) => {
     const app = express();
@@ -145,8 +130,103 @@ export const startApiServer = (port, argv) => {
             checker.options = req.body;
             try {
                 console.log('Applying the database structure based on JSON dumps');
-                await applyDifferences(checker.connection, database, diffs);
-                res.json({ message: 'Apply completed successfully' });
+                const { attempted, failures, warnings } = await applyDifferences(checker.connection, database, diffs);
+                const warningText = warnings.length
+                    ? ` ${warnings.length} applied with changes: ` + warnings.map(w => `${w.description} (${w.message})`).join('; ')
+                    : '';
+                if (failures.length) {
+                    // Reporting success here would be a lie: the same differences come
+                    // back on the next compare with no indication of why.
+                    res.status(500).json({
+                        message: `Applied ${attempted - failures.length} of ${attempted}. ${failures.length} failed: `
+                            + failures.map(f => `${f.description} (${f.message})`).join('; ') + warningText,
+                        failures,
+                        warnings,
+                    });
+                } else {
+                    res.json({
+                        message: `Applied ${attempted} of ${attempted}.` + warningText,
+                        warnings,
+                    });
+                }
+            } catch (err) {
+                res.status(500).json({ message: err.message });
+            } finally {
+                await checker.closeConnection();
+            }
+        });
+    });
+
+    // API endpoint for tables whose tables/<table>.sql disagrees with the createSQL in the
+    // template's JSON. Reads only the template, so no database connection is needed
+    app.post('/api/templateDrift', async (req, res) => {
+        const config = setConfig(req.body.config || {}, argv);
+        if (!config.output) return res.status(400).json({ message: 'No template folder selected' });
+        try {
+            res.json(await findTemplateDrift(config.output));
+        } catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+
+    // API endpoint to make one table's JSON createSQL and .sql file agree, keeping 'json' or 'sql'
+    app.post('/api/resolveTemplateDrift', async (req, res) => {
+        const { database, table, keep } = req.body;
+        const config = setConfig(req.body.config || {}, argv);
+        if (!config.output) return res.status(400).json({ message: 'No template folder selected' });
+        try {
+            await resolveTemplateDrift(config.output, database, table, keep);
+            res.json({ message: `${database}.${table}: kept the ${keep === 'json' ? 'JSON' : '.sql file'} version` });
+        } catch (err) {
+            res.status(500).json({ message: err.message });
+        }
+    });
+
+    // API endpoint for the server's and the template's MySQL versions
+    app.post('/api/versions', async (req, res) => {
+        let { config } = req.body;
+        config = setConfig(config || {}, argv);
+        const checker = new DBStructureChecker(config);
+
+        checker.connection.on('error', (err) => {
+            if (!res.headersSent) res.status(500).json({ message: 'Database connection failed', error: err.message });
+        });
+
+        checker.connection.on('connect', async () => {
+            try {
+                res.json(await getVersionInfo(checker.connection, config.output));
+            } catch (err) {
+                res.status(500).json({ message: err.message });
+            } finally {
+                await checker.closeConnection();
+            }
+        });
+    });
+
+    // API endpoint to overwrite the template with the database's current values
+    app.post('/api/acceptCurrent', async (req, res) => {
+        let { config, database, diffs } = req.body;
+        config = setConfig(config, argv);
+        if (!config.output) {
+            return res.status(400).json({ message: 'No template folder selected' });
+        }
+        try {
+            assertOutsidePackage(config.output);
+        } catch (err) {
+            return res.status(400).json({ message: err.message });
+        }
+        const checker = new DBStructureChecker(config, database);
+
+        checker.connection.on('error', (err) => {
+            console.error('Database connection error in route acceptCurrent:', err);
+            if (!res.headersSent) res.status(500).json({ message: 'Database connection failed', error: err.message });
+        });
+
+        checker.connection.on('connect', async () => {
+            try {
+                console.log(`Keeping current values in the template for ${diffs?.length ?? 0} difference(s) in ${database}`);
+                await acceptCurrentIntoTemplate(checker.connection, config.output, database, diffs || []);
+                res.json({ message: 'Template updated with the current values' });
             } catch (err) {
                 res.status(500).json({ message: err.message });
             } finally {
@@ -157,7 +237,8 @@ export const startApiServer = (port, argv) => {
 
     app.post('/api/browse-folders', async (req, res) => {
         try {
-            const { currentPath = packageRoot } = req.body;
+            // Start where mysqlsyncr was run from, not in the package folder
+            const { currentPath = process.cwd() } = req.body;
             console.log('Browsing folder:', currentPath);
 
             const resolvedPath = currentPath.startsWith('/') || currentPath.match(/^[A-Z]:\\/)
@@ -210,7 +291,8 @@ export const startApiServer = (port, argv) => {
 
             const resolvedPath = folderPath.startsWith('/') || folderPath.match(/^[A-Z]:\\/)
                 ? resolve(folderPath)
-                : resolve(packageRoot, folderPath);
+                : resolve(process.cwd(), folderPath);
+            assertOutsidePackage(resolvedPath);
 
             await mkdir(resolvedPath, { recursive: true });
 

package/src/templateDrift.js

@@ -0,0 +1,93 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { parseCreateTableSQL } from './parsers.js';
+import { assertOutsidePackage } from './paths.js';
+
+/**
+ * Split a tables/<table>.sql file into its CREATE TABLE statement (without a
+ * trailing semicolon) and whatever follows it, such as notes written by hand.
+ */
+export const splitSqlFile = (content) => {
+    const lines = content.replace(/\r\n/g, '\n').split('\n');
+    const start = lines.findIndex(line => /^\s*CREATE TABLE/i.test(line));
+    let end = start === -1 ? -1 : lines.findIndex((line, i) => i > start && line.trim().startsWith(')'));
+    if (start === -1 || end === -1) return { statement: content.trim(), semicolon: false, before: '', after: '' };
+    const closing = lines[end].replace(/\s+$/, '');
+    const semicolon = closing.endsWith(';');
+    return {
+        before: lines.slice(0, start).join('\n'),
+        statement: [...lines.slice(start, end), semicolon ? closing.slice(0, -1) : closing].join('\n'),
+        semicolon,
+        after: lines.slice(end + 1).join('\n')
+    };
+}
+
+const joinSqlFile = ({ before, statement, semicolon, after }) =>
+    `${before ? `${before}\n` : ''}${statement}${semicolon ? ';' : ''}\n${after.trim() ? `${after.replace(/\n+$/, '')}\n` : ''}`;
+
+const sameStatement = (a, b) => a.replace(/\r\n/g, '\n').replace(/;?\s*$/, '') === b.replace(/\r\n/g, '\n').replace(/;?\s*$/, '');
+
+/**
+ * Tables whose tables/<table>.sql statement differs from the createSQL in the
+ * database's JSON (which is what comparing uses). Notes after the statement
+ * don't count. Returns [{ database, table, file, json, sql }].
+ */
+export const findTemplateDrift = async (dir) => {
+    const drift = [];
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries.filter(e => e.isDirectory())) {
+        const database = entry.name;
+        let structure;
+        try {
+            structure = JSON.parse(await fs.readFile(path.join(dir, database, `${database}.json`), 'utf-8'));
+        } catch {
+            continue;
+        }
+        for (const [table, contents] of Object.entries(structure.tables || {})) {
+            if (!contents.createSQL) continue;
+            const file = path.join('tables', `${table}.sql`);
+            const content = await fs.readFile(path.join(dir, database, file), 'utf-8').catch(() => null);
+            if (content === null) continue;
+            const { statement } = splitSqlFile(content);
+            if (!sameStatement(statement, contents.createSQL)) {
+                drift.push({ database, table, file: file.replace(/\\/g, '/'), json: contents.createSQL.replace(/;\s*$/, ''), sql: statement });
+            }
+        }
+    }
+    return drift;
+}
+
+/**
+ * Make one table's JSON createSQL and tables/<table>.sql agree.
+ *   keep 'json': the .sql file's statement is replaced by the JSON's createSQL; notes after it stay
+ *   keep 'sql':  the JSON's createSQL becomes the .sql file's statement, and its
+ *                columns/indexes/constraints are re-read from it
+ */
+export const resolveTemplateDrift = async (dir, database, table, keep) => {
+    if (keep !== 'json' && keep !== 'sql') throw new Error(`keep must be 'json' or 'sql', not ${keep}`);
+    assertOutsidePackage(dir);
+    const jsonPath = path.join(dir, database, `${database}.json`);
+    const sqlPath = path.join(dir, database, 'tables', `${table}.sql`);
+    const structure = JSON.parse(await fs.readFile(jsonPath, 'utf-8'));
+    const contents = structure.tables?.[table];
+    if (!contents?.createSQL) throw new Error(`${database}.${table} has no createSQL in ${database}.json`);
+    const parts = splitSqlFile(await fs.readFile(sqlPath, 'utf-8'));
+
+    if (keep === 'json') {
+        await fs.writeFile(sqlPath, joinSqlFile({ ...parts, statement: contents.createSQL.replace(/;\s*$/, '') }), 'utf-8');
+        return;
+    }
+
+    const parsed = parseCreateTableSQL(parts.statement);
+    if (!parsed || parsed.name !== table) {
+        throw new Error(`tables/${table}.sql doesn't hold a CREATE TABLE for ${table}`);
+    }
+    structure.tables[table] = {
+        ...contents,
+        columns: parsed.columns,
+        indexes: parsed.indexes,
+        constraints: parsed.constraints,
+        createSQL: parts.statement
+    };
+    await fs.writeFile(jsonPath, JSON.stringify(structure, null, 4), 'utf-8');
+}

package/src/versions.js

@@ -0,0 +1,112 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+// '8.0.36-log' -> { major: 8, minor: 0 }; also takes '5.7'
+const parseVersion = (version) => {
+    const match = typeof version === 'string' && version.match(/^(\d+)\.(\d+)/);
+    return match ? { major: Number(match[1]), minor: Number(match[2]) } : null;
+}
+
+export const majorMinor = (version) => {
+    const parsed = parseVersion(version);
+    return parsed ? `${parsed.major}.${parsed.minor}` : null;
+}
+
+const isBefore80 = (version) => {
+    const parsed = parseVersion(version);
+    return !!parsed && parsed.major < 8;
+}
+
+export const getServerVersion = async (connection) => {
+    try {
+        const rows = await connection.query('SELECT VERSION() AS version');
+        return rows?.[0]?.version ?? null;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * The MySQL version a template was dumped from: recorded in dumpInfo.json by
+ * dump, or else inferred from how its SQL is written. Returns
+ * { version, inferred, reason? } or null when it can't tell.
+ */
+export const getTemplateVersion = async (dir) => {
+    try {
+        const info = JSON.parse(await fs.readFile(path.join(dir, 'dumpInfo.json'), 'utf-8'));
+        if (info.mysqlVersion) return { version: info.mysqlVersion, inferred: false };
+    } catch {
+        // No dumpInfo.json, or written before versions were recorded
+    }
+
+    let sql = '';
+    try {
+        for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+            if (!entry.isDirectory()) continue;
+            try {
+                const structure = JSON.parse(await fs.readFile(path.join(dir, entry.name, `${entry.name}.json`), 'utf-8'));
+                sql += Object.values(structure.tables || {}).map(t => t.createSQL || '').join('\n');
+            } catch {
+                // Not a database folder
+            }
+        }
+    } catch {
+        return null;
+    }
+    if (/utf8mb4_0900_|\butf8mb3\b/i.test(sql)) {
+        return { version: '8.0', inferred: true, reason: 'uses utf8mb4_0900 collations or utf8mb3, which only 8.0 prints' };
+    }
+    if (/\b(?:smallint|mediumint|int|bigint)\(\d+\)|\btinyint\((?!1\))\d+\)/i.test(sql)) {
+        return { version: '5.7', inferred: true, reason: 'shows integer display widths like int(11), as 5.7 and 8.0 before 8.0.19 do' };
+    }
+    if (/\b(?:smallint|mediumint|int|bigint)\b(?!\()/i.test(sql)) {
+        return { version: '8.0', inferred: true, reason: 'shows integers without display widths, as 8.0.19 and later do' };
+    }
+    return null;
+}
+
+/**
+ * What to know when the template and the server are different MySQL versions.
+ */
+export const versionNotes = (templateVersion, serverVersion) => {
+    const template = majorMinor(templateVersion);
+    const server = majorMinor(serverVersion);
+    if (!template || !server || template === server) return [];
+    const notes = [
+        `The template is from MySQL ${template} and the server is MySQL ${server}. Integer display widths (int(11) vs int), YEAR(4) and utf8 vs utf8mb3 are printed differently by these versions and are ignored when comparing.`
+    ];
+    if (isBefore80(serverVersion) && !isBefore80(templateVersion)) {
+        notes.push(`MySQL ${server} has no utf8mb4_0900 collations, so tables and columns are created with utf8mb4_unicode_ci (utf8mb4_bin for accent- or case-sensitive ones) instead.`);
+        notes.push(`Expression defaults such as DEFAULT (...) need MySQL 8.0.13 or later and fail on MySQL ${server}.`);
+    }
+    return notes;
+}
+
+export const getVersionInfo = async (connection, templateDir) => {
+    const server = await getServerVersion(connection);
+    const template = await getTemplateVersion(templateDir);
+    return { server, template, notes: versionNotes(template?.version, server) };
+}
+
+// MySQL 8 added the _0900_ collation family, which does not exist on 5.7. The _unicode_ci
+// collation of the same charset is accent- and case-insensitive like _0900_ai_ci and is
+// present on both versions, so a table created with it means the same thing either way.
+// Accent- or case-sensitive _0900_ collations map to the charset's _bin. Null if collation
+// isn't a _0900_ one.
+export const portableCollation = (collation) => {
+    const match = /^(\w+?)_0900_(\w+)$/i.exec(collation || '');
+    if (!match) return null;
+    return /^(?:ai_ci|as_ci)$/i.test(match[2]) ? `${match[1]}_unicode_ci` : `${match[1]}_bin`;
+}
+
+/**
+ * Rewrite SQL from a template so the server can run it: MySQL 5.7 doesn't
+ * know the utf8mb4_0900 collations that 8.0 uses by default, or the utf8mb3_
+ * collation names 8.0 prints.
+ */
+export const adaptSQLForServer = (sql, serverVersion) => {
+    if (typeof sql !== 'string' || !isBefore80(serverVersion)) return sql;
+    return sql
+        .replace(/\b\w+?_0900_\w+/gi, (collation) => portableCollation(collation) ?? collation)
+        .replace(/\butf8mb3_(\w+)/gi, 'utf8_$1');
+}