mysqlsyncr 1.1.10 → 1.2.1

package/src/parsers.js

@@ -1,145 +1,197 @@
-export const parseCreateTableSQL = (createTableSQL) => {
-    if(!createTableSQL) return null;
-    const name = createTableSQL.match(/CREATE TABLE\s+`([^`]+)`/)[1];
-    const columns = [];
-    const indexes = [];
-    const constraints = [];
-    let engine = null;
-    let charset = null;
-    let collate = null;
-
-    // Split the SQL statement into lines and filter out empty lines
-    const lines = createTableSQL.split('\n').map(line => line.trim()).filter(line => line.length > 0);
-
-    // Regular expression to match column definitions
-    const columnRegex = /`([^`]+)`\s+([^\s,]+)(\s+NOT NULL|\s+NULL)?(\s+DEFAULT\s+([^,\s]+))?(\s+AUTO_INCREMENT)?/;
-
-    // Regular expression to match index definitions
-    const indexRegex = /(PRIMARY|UNIQUE)?\s*KEY\s*`([^`]+)`\s*\(([^)]+)\)|PRIMARY KEY\s*\(([^)]+)\)/;
-
-    // Regular expression to match table options (ENGINE, CHARSET, COLLATE)
-    const optionsRegex = /ENGINE=(\w+)\s+DEFAULT\s+CHARSET=(\w+)(\s+COLLATE=(\w+))?/;
-
-
-    // Process each line
-    for (const line of lines) {
-        if (line.includes('CREATE TABLE')) {
-            continue;
-        }
-        // Check if the line contains a column definition
-        const columnMatch = columnRegex.exec(line);
-        const indexMatch = indexRegex.exec(line);
-        const constraintMatch = parseConstraint(line);
-        if (columnMatch && !indexMatch && !constraintMatch) {
-            const columnType = parseColumnType(line);
-            const column = {
-                Field: columnMatch[1],
-                Type: columnType
-            };
-
-            // Set Null property based on NOT NULL presence
-            if (columnMatch[3] && columnMatch[3].includes('NOT NULL')) {
-                column.NotNull = true; // Set to false if NOT NULL is present
-            }
-
-            // Set Default property if it exists
-            if (columnMatch[5]) {
-                // console.log('columnMatch[5]', columnMatch[5], columnMatch[5].replace(/'/g, ''))
-                column.Default = columnMatch[5].replace(/'/g, '');
-            }
-
-            // Set AutoIncrement property if it exists
-            if (columnMatch[6]) {
-                column.AutoIncrement = true; // Set to true if AUTO_INCREMENT is present
-            }
-
-            columns.push(column);
-        } else if (indexMatch && !constraintMatch) {
-
-            const isPrimary = line.includes("PRIMARY KEY"); // Check for PRIMARY in both patterns
-            const isUnique = line.includes("UNIQUE KEY"); // Only set Unique if it matches
-
-            const keyName = isPrimary ? null : indexMatch[2]; // Set KeyName to null if it's a primary key
-            const columnNames = indexMatch[3] 
-            ? indexMatch[3].split(',').map(col => col.trim().replace(/`/g, '')) // Remove backticks
-            : indexMatch[4].split(',').map(col => col.trim().replace(/`/g, '')); // Remove backticks
-            const index = {
-                ColumnName: columnNames
-            };
-            if (isPrimary) index.Primary = true, index.Name = "PRIMARY"
-            if (isUnique) index.Unique = true;
-            if (keyName) index.Name = keyName;
-            indexes.push(index);
-
-        } else if (constraintMatch) {
-            constraints.push(constraintMatch);
-        }
-
-    }
-
-    // Handle table options
-    const optionsMatch = optionsRegex.exec(createTableSQL);
-    if (optionsMatch) {
-        engine = optionsMatch[1];
-        charset = optionsMatch[2];
-        collate = optionsMatch[4] || null; // Collate may not be present
-    }
-    return { name, columns, indexes, constraints, engine, charset, collate };
-}
-
-export const parseConstraint = (sql) => {
-    if(!sql) return null;
-    const regex = /FOREIGN KEY \((`[^`]+`)\) REFERENCES (`[^`]+`)\s?\((`[^`]+`)\)(?:\sON DELETE (NO|CASCADE|SET NULL|SET DEFAULT))?(?:\sON UPDATE (NO ACTION|CASCADE|SET NULL|SET DEFAULT))?/i;
-    const match = sql.match(regex);
-
-    if (!match) {
-        return null;
-    }
-    let onDelete = null;    
-    let onUpdate = null;
-    if(sql.includes('ON DELETE CASCADE')){
-        onDelete = 'CASCADE';
-    }else if(sql.includes('ON DELETE SET NULL')){
-        onDelete = 'SET NULL';
-    }else if(sql.includes('ON DELETE SET DEFAULT')){
-        onDelete = 'SET DEFAULT';
-    }else{
-        onDelete = 'NO ACTION';
-    }
-
-    if(sql.includes('ON UPDATE CASCADE')){
-        onUpdate = 'CASCADE';
-    }else if(sql.includes('ON UPDATE SET NULL')){
-        onUpdate = 'SET NULL';
-    }else if(sql.includes('ON UPDATE SET DEFAULT')){
-        onUpdate = 'SET DEFAULT';
-    }else{
-        onUpdate = 'NO ACTION';
-    }
-    let columnName = match[1] || ''
-    columnName = columnName.replace(/`/g, '')
-    let table = match[2] || ''
-    table = table.replace(/`/g, '')
-    let column = match[3] || ''
-    column = column.replace(/`/g, '')
-    return {
-        Name: "AlertRule", // Replace with actual constraint name if needed
-        Type: "FOREIGN KEY",
-        ColumnName: [columnName], // Column in the current table
-        References: {
-            Table: table, // Referenced table
-            Column: column, // Referenced column
-        },
-        OnDelete: onDelete, 
-        OnUpdate: onUpdate, 
-    };
-};
-
-const parseColumnType = (line) => {
-    // Match type pattern including parameters, handling both single and double parameter types
-    const typeRegex = /`[^`]+`\s+([a-zA-Z]+(?:\([0-9]+(?:,[0-9]+)?\))?)/i;
-    const match = line.match(typeRegex);
-    
-    if (!match) return null;
-    return match[1]; // Returns the full type including parameters
-};
+export const parseCreateTableSQL = (createTableSQL) => {
+    if(!createTableSQL) return null;
+    const name = createTableSQL.match(/CREATE TABLE\s+`([^`]+)`/)[1];
+    const columns = [];
+    const indexes = [];
+    const constraints = [];
+    let engine = null;
+    let charset = null;
+    let collate = null;
+
+    // Split the SQL statement into lines and filter out empty lines
+    const lines = createTableSQL.split('\n').map(line => line.trim()).filter(line => line.length > 0);
+
+    // Regular expression to match index definitions
+    const indexRegex_Old = /(PRIMARY|UNIQUE)?\s*KEY\s*`([^`]+)`\s*\(([^)]+)\)|PRIMARY KEY\s*\(([^)]+)\)/;
+
+    // Updated to support indexes for text fields 
+    // 'KEY `idx_e2alarms_alarmstring` (`alarmString`(255))' -- would cut off the final bracket and wouldnt work.
+    const indexRegex = /(PRIMARY|UNIQUE)?\s*KEY\s*`([^`]+)`\s*\(((?:`[^`]+`(?:\(\d+\))?(?:\s*,\s*)?)+)\)|PRIMARY KEY\s*\(((?:`[^`]+`(?:\(\d+\))?(?:\s*,\s*)?)+)\)/;
+
+    // Regular expression to match table options (ENGINE, CHARSET, COLLATE)
+    const optionsRegex = /ENGINE=(\w+)\s+DEFAULT\s+CHARSET=(\w+)(\s+COLLATE=(\w+))?/;
+
+
+    // Process each line
+    for (const line of lines) {
+        if (line.includes('CREATE TABLE')) {
+            continue;
+        }
+        // Column definitions are the only lines that start with a backticked name
+        const column = parseColumnDefinition(line);
+        const indexMatch = indexRegex.exec(line);
+
+        const constraintMatch = parseConstraint(line);
+        if (column) {
+            columns.push(column);
+        } else if (indexMatch && !constraintMatch) {
+
+            const isPrimary = line.includes("PRIMARY KEY"); // Check for PRIMARY in both patterns
+            const isUnique = line.includes("UNIQUE KEY"); // Only set Unique if it matches
+
+            const keyName = isPrimary ? null : indexMatch[2]; // Set KeyName to null if it's a primary key
+            const columnNames = indexMatch[3] 
+            ? indexMatch[3].split(',').map(col => col.trim().replace(/`/g, '')) // Remove backticks
+            : indexMatch[4].split(',').map(col => col.trim().replace(/`/g, '')); // Remove backticks
+            const index = {
+                ColumnName: columnNames
+            };
+            if (isPrimary) index.Primary = true, index.Name = "PRIMARY"
+            if (isUnique) index.Unique = true;
+            if (keyName) index.Name = keyName;
+            indexes.push(index);
+
+        } else if (constraintMatch) {
+            constraints.push(constraintMatch);
+        }
+
+    }
+
+    // Handle table options
+    const optionsMatch = optionsRegex.exec(createTableSQL);
+    if (optionsMatch) {
+        engine = optionsMatch[1];
+        charset = optionsMatch[2];
+        collate = optionsMatch[4] || null; // Collate may not be present
+    }
+    return { name, columns, indexes, constraints, engine, charset, collate };
+}
+
+export const parseConstraint = (sql) => {
+    if(!sql) return null;
+    const regex = /FOREIGN KEY \((`[^`]+`)\) REFERENCES (`[^`]+`)\s?\((`[^`]+`)\)(?:\sON DELETE (NO|CASCADE|SET NULL|SET DEFAULT))?(?:\sON UPDATE (NO ACTION|CASCADE|SET NULL|SET DEFAULT))?/i;
+    const match = sql.match(regex);
+
+    if (!match) {
+        return null;
+    }
+    let onDelete = null;    
+    let onUpdate = null;
+    if(sql.includes('ON DELETE CASCADE')){
+        onDelete = 'CASCADE';
+    }else if(sql.includes('ON DELETE SET NULL')){
+        onDelete = 'SET NULL';
+    }else if(sql.includes('ON DELETE SET DEFAULT')){
+        onDelete = 'SET DEFAULT';
+    }else{
+        onDelete = 'NO ACTION';
+    }
+
+    if(sql.includes('ON UPDATE CASCADE')){
+        onUpdate = 'CASCADE';
+    }else if(sql.includes('ON UPDATE SET NULL')){
+        onUpdate = 'SET NULL';
+    }else if(sql.includes('ON UPDATE SET DEFAULT')){
+        onUpdate = 'SET DEFAULT';
+    }else{
+        onUpdate = 'NO ACTION';
+    }
+    let columnName = match[1] || ''
+    columnName = columnName.replace(/`/g, '')
+    let table = match[2] || ''
+    table = table.replace(/`/g, '')
+    let column = match[3] || ''
+    column = column.replace(/`/g, '')
+    return {
+        Name: "AlertRule", // Replace with actual constraint name if needed
+        Type: "FOREIGN KEY",
+        ColumnName: [columnName], // Column in the current table
+        References: {
+            Table: table, // Referenced table
+            Column: column, // Referenced column
+        },
+        OnDelete: onDelete, 
+        OnUpdate: onUpdate, 
+    };
+};
+
+// A quoted SQL string, allowing '' and backslash escapes inside it
+const quotedStringRegex = /'(?:[^'\\]|\\.|'')*'/g;
+
+const unquote = (quoted) => quoted.slice(1, -1).replace(/''/g, "'").replace(/\\(.)/g, '$1');
+
+// Type with its parameters: int, float(10,2), enum('a','b'), varchar(45); then unsigned/zerofill
+const columnTypeRegex = /^([a-zA-Z]+(?:\((?:'(?:[^'\\]|\\.|'')*'|[^)'])*\))?)((?:\s+(?:unsigned|zerofill)\b)*)/i;
+
+/**
+ * Parse one column line of a SHOW CREATE TABLE statement, e.g.
+ *   `IID` varchar(25) COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT 'x',
+ * Returns null if the line isn't a column definition.
+ */
+export const parseColumnDefinition = (line) => {
+    const lineMatch = line.trim().match(/^`([^`]+)`\s+(.*?),?$/);
+    if (!lineMatch) return null;
+    const typeMatch = lineMatch[2].match(columnTypeRegex);
+    if (!typeMatch) return null;
+
+    const column = {
+        Field: lineMatch[1],
+        // unsigned/zerofill are part of the type: a column restated without them changes
+        Type: typeMatch[1] + typeMatch[2].toLowerCase()
+    };
+
+    // Swap quoted strings for numbered placeholders so keywords inside a
+    // COMMENT or DEFAULT value aren't matched as attributes
+    const strings = [];
+    const quoted = [];
+    const rest = lineMatch[2].slice(typeMatch[0].length).replace(quotedStringRegex, (text) => {
+        strings.push(unquote(text));
+        quoted.push(text);
+        return `'${strings.length - 1}'`;
+    });
+    // Put the original quoted text back, e.g. b'0' or (_utf8mb4'[]')
+    const restoreQuoted = (text) => text.replace(/'(\d+)'/g, (_, i) => quoted[i]);
+
+    if (/\bNOT NULL\b/i.test(rest)) {
+        column.NotNull = true;
+    }
+
+    const defaultMatch = rest.match(/\bDEFAULT\s+('\d+'|\((?:[^()]|\([^()]*\))*\)|[^\s,]+)/i);
+    if (defaultMatch) {
+        // A plain string default is stored unquoted; anything else (NULL,
+        // CURRENT_TIMESTAMP, b'0', an expression) is kept as written
+        const whole = defaultMatch[1].match(/^'(\d+)'$/);
+        column.Default = whole ? strings[whole[1]] : restoreQuoted(defaultMatch[1]);
+    }
+
+    const generatedMatch = rest.match(/\bGENERATED ALWAYS AS\s*(\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\))\s*(STORED|VIRTUAL)?/i);
+    if (generatedMatch) {
+        column.Generated = `${restoreQuoted(generatedMatch[1])}${generatedMatch[2] ? ` ${generatedMatch[2].toUpperCase()}` : ''}`;
+    }
+
+    if (/\bAUTO_INCREMENT\b/i.test(rest)) {
+        column.AutoIncrement = true;
+    }
+
+    const onUpdateMatch = rest.match(/\bON UPDATE\s+(CURRENT_TIMESTAMP(?:\(\d*\))?)/i);
+    if (onUpdateMatch) {
+        column.OnUpdate = onUpdateMatch[1];
+    }
+
+    const charsetMatch = rest.match(/\bCHARACTER SET\s+(\w+)/i);
+    if (charsetMatch) {
+        column.Charset = charsetMatch[1];
+    }
+
+    const collateMatch = rest.match(/\bCOLLATE\s+(\w+)/i);
+    if (collateMatch) {
+        column.Collate = collateMatch[1];
+    }
+
+    const commentMatch = rest.match(/\bCOMMENT\s+'(\d+)'/i);
+    if (commentMatch) {
+        column.Comment = strings[commentMatch[1]];
+    }
+
+    return column;
+};

package/src/paths.js

@@ -0,0 +1,41 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// The mysqlsyncr package folder, from src/ or the dist/ build. The CJS build
+// rewrites import.meta.url from __filename; a global __dirname can't be trusted
+// (node -e sets it to '.')
+export const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+export const isInsidePackage = (dir) => {
+    const relative = path.relative(packageRoot, path.resolve(dir));
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+/**
+ * Throw if dir is the mysqlsyncr package folder or inside it. Dumps and
+ * templates kept there are lost when the package is reinstalled or updated.
+ */
+export const assertOutsidePackage = (dir) => {
+    if (dir && isInsidePackage(dir)) {
+        throw new Error(`${path.resolve(dir)} is inside the mysqlsyncr package folder (${packageRoot}). Choose a folder outside it with --output.`);
+    }
+}
+
+/**
+ * Why dir can't be read as a template: it doesn't exist, isn't a folder, or has
+ * no <database>/<database>.json in it. Null when it's usable.
+ */
+export const templateFolderProblem = (dir) => {
+    const resolved = path.resolve(dir);
+    let stat;
+    try {
+        stat = fs.statSync(resolved);
+    } catch {
+        return `${resolved} doesn't exist.`;
+    }
+    if (!stat.isDirectory()) return `${resolved} isn't a folder.`;
+    const hasDatabase = fs.readdirSync(resolved, { withFileTypes: true })
+        .some(entry => entry.isDirectory() && fs.existsSync(path.join(resolved, entry.name, `${entry.name}.json`)));
+    return hasDatabase ? null : `${resolved} has no template in it (no <database>/<database>.json). Run dump first, or choose the template folder.`;
+}

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;
+}