mysqlsyncr 1.1.10 → 1.2.1

package/src/loggers.js

@@ -1,140 +1,157 @@
-let isVerbose = false; // Global variable to manage verbosity
-
-export const setVerbose = (verbose) => {
-    isVerbose = verbose; // Function to set the verbosity level
-};
-
-export const logger = (...args) => {
-    if (isVerbose) {
-        console.log(...args); // Log all arguments if verbose is enabled
-    }
-};
-
-export const logDifferences = (differences, database, dryRun) => {
-    const formattedDifferences = differences.map(diff => {
-        switch (diff.type) {
-            case 'missing_procedure':
-                return {
-                    Type: diff.type,
-                    Name: diff.Name,
-                    Details: `Procedure ${diff.Name} is missing`,
-                    Action: 'Procedure is missing',
-                };
-            case 'mismatched_procedure':
-
-                return {
-                    Type: diff.type,
-                    Name: diff.Name,
-                    Details: `Mismatched procedure ${diff.Name}`,
-                    Action: 'Mismatched procedure',
-                };
-            case 'missing_field':
-                return {
-                    Type: diff.type,
-                    Name: diff.tableName,
-                    Details: `Field ${diff.field.Field} is missing`,
-                    Action: 'Field is missing',
-                };
-            case 'missing_table':
-                return {
-                    Type: diff.type,
-                    Name: diff.tableName,
-                    Details: `Table ${diff.tableName} is missing`,
-                    Action: 'Table is missing',
-                };
-            case 'extra_field':
-                return {
-                    Type: diff.type,
-                    Name: diff.tableName,
-                    Details: `Field ${diff.field.Field} is extra`,
-                    Action: 'Field is extra',
-                };
-            case 'extra_table':
-                return {
-                    Type: diff.type,
-                    Name: diff.tableName,
-                    Details: `Table ${diff.tableName} is extra`,
-                    Action: 'Table is extra',
-                };
-            case 'missing_view':
-                return {
-                    Type: diff.type,
-                    Name: diff.viewName,
-                    Details: `View ${diff.viewName} is missing`,
-                    Action: 'View is missing',
-                };
-            case 'extra_index':
-                return {
-                    Type: diff.type,
-                    Name: diff.tableName,
-                    Details: `Index ${diff.index.Name} is extra`,
-                    Action: 'Index is extra',
-                };
-            case 'missing_index':
-                return {
-                    Type: diff.type,
-                    TableName: diff.tableName,
-                    Name: diff.index.Name,
-                    Details: `Index ${diff.index.Name} is missing`,
-                    Action: 'Index is missing',
-                };
-
-            case 'mismatched_index':
-                return {
-                    Type: diff.type,
-                    TableName: diff.tableName,
-                    Name: diff.index.Name,
-                    From: diff.from,
-                    Details: `Index ${diff.index.Name} is mismatched`,
-                    Action: 'Index is mismatched',
-                };
-
-            case 'extra_trigger':
-                return {
-                    Type: diff.type,
-                    Name: diff.trigger.Name,
-                    Details: `Trigger ${diff.trigger.Name} is extra`,
-                    Action: 'Trigger is extra',
-                };
-            case 'mismatched_trigger':
-                return {
-                    Type: diff.type,
-                    Name: diff.trigger.Name,
-                    Details: `Trigger ${diff.trigger.Name} is mismatched`,
-                    Action: 'Trigger is mismatched',
-                };  
-            case 'missing_trigger':
-                console.log('missing_trigger', diff)
-                return {
-                    Type: diff.type,
-                    Name: diff.trigger.Name,
-                    Details: `Trigger ${diff.trigger.Name} is missing`,
-                    Action: 'Trigger is missing',
-                };
-            default:
-                return {
-                    Type: diff.type,
-                    Details: `Unhandled difference type: ${diff.type}`,
-                };
-        }
-    });
-
-    // Filter out any undefined or null entries
-    const filteredDifferences = formattedDifferences.filter(diff => diff);
-
-    // Log the differences in a table format
-    if (filteredDifferences.length > 0) {
-        if (dryRun) {
-            logger(`Dry Run: Differences for database ${database}:`);
-        } else {
-            logger(`Differences applied for database ${database}:`);
-        }
-        console.table(filteredDifferences);
-    } else {
-        if (dryRun) {
-            logger(`Dry Run: No differences found. Database: ${database}`);
-        } else {
-            logger(`No differences found. Database: ${database}`);
-        }
-    }
+let isVerbose = false; // Global variable to manage verbosity
+
+export const setVerbose = (verbose) => {
+    isVerbose = verbose; // Function to set the verbosity level
+};
+
+export const logger = (...args) => {
+    if (isVerbose) {
+        console.log(...args); // Log all arguments if verbose is enabled
+    }
+};
+
+export const logDifferences = (differences, database, dryRun) => {
+    const formattedDifferences = differences.map(diff => {
+        switch (diff.type) {
+            case 'missing_procedure':
+                return {
+                    Type: diff.type,
+                    Name: diff.Name,
+                    Details: `Procedure ${diff.Name} is missing`,
+                    Action: 'Procedure is missing',
+                };
+            case 'mismatched_procedure':
+
+                return {
+                    Type: diff.type,
+                    Name: diff.Name,
+                    Details: `Mismatched procedure ${diff.Name}`,
+                    Action: 'Mismatched procedure',
+                };
+            case 'missing_field':
+                return {
+                    Type: diff.type,
+                    Name: diff.tableName,
+                    Details: `Field ${diff.field.Field} is missing`,
+                    Action: 'Field is missing',
+                };
+            case 'mismatched_field': {
+                // `info` names the check that failed; Null is stored as NotNull.
+                const property = diff.info === 'Null' ? 'NotNull' : diff.info;
+                return {
+                    Type: diff.type,
+                    Name: diff.tableName,
+                    Details: `Field ${diff.field.Field} ${diff.info} is ${JSON.stringify(diff.currentField?.[property])}, expected ${JSON.stringify(diff.field?.[property])}`,
+                    Action: 'Field is mismatched',
+                };
+            }
+            case 'missing_table':
+                return {
+                    Type: diff.type,
+                    Name: diff.tableName,
+                    Details: `Table ${diff.tableName} is missing`,
+                    Action: 'Table is missing',
+                };
+            case 'extra_field':
+                return {
+                    Type: diff.type,
+                    Name: diff.tableName,
+                    Details: `Field ${diff.field.Field} is extra`,
+                    Action: 'Field is extra',
+                };
+            case 'extra_table':
+                return {
+                    Type: diff.type,
+                    Name: diff.tableName,
+                    Details: `Table ${diff.tableName} is extra`,
+                    Action: 'Table is extra',
+                };
+            case 'missing_view':
+                return {
+                    Type: diff.type,
+                    Name: diff.viewName,
+                    Details: `View ${diff.viewName} is missing`,
+                    Action: 'View is missing',
+                };
+            case 'extra_index':
+                return {
+                    Type: diff.type,
+                    Name: diff.tableName,
+                    Details: `Index ${diff.index.Name} is extra`,
+                    Action: 'Index is extra',
+                };
+            case 'missing_index':
+                return {
+                    Type: diff.type,
+                    TableName: diff.tableName,
+                    Name: diff.index.Name,
+                    Details: `Index ${diff.index.Name} is missing`,
+                    Action: 'Index is missing',
+                };
+
+            case 'mismatched_index':
+                return {
+                    Type: diff.type,
+                    TableName: diff.tableName,
+                    Name: diff.index.Name,
+                    From: diff.from,
+                    Details: `Index ${diff.index.Name} is mismatched`,
+                    Action: 'Index is mismatched',
+                };
+
+            case 'extra_trigger':
+                return {
+                    Type: diff.type,
+                    Name: diff.trigger.Name,
+                    Details: `Trigger ${diff.trigger.Name} is extra`,
+                    Action: 'Trigger is extra',
+                };
+            case 'mismatched_trigger':
+                return {
+                    Type: diff.type,
+                    Name: diff.trigger.Name,
+                    Details: `Trigger ${diff.trigger.Name} is mismatched`,
+                    Action: 'Trigger is mismatched',
+                };  
+            case 'missing_trigger':
+                logger('missing_trigger', diff)
+                return {
+                    Type: diff.type,
+                    Name: diff.trigger.Name,
+                    Details: `Trigger ${diff.trigger.Name} is missing`,
+                    Action: 'Trigger is missing',
+                };
+            case 'missing_row':
+                return {
+                    Type: diff.type,
+                    Name: diff.tableName,
+                    Details: `Row ${JSON.stringify(diff.key)} is missing`,
+                    Action: 'Row is missing',
+                };
+            default:
+                return {
+                    Type: diff.type,
+                    Details: `Unhandled difference type: ${diff.type}`,
+                };
+        }
+    });
+
+    // Filter out any undefined or null entries
+    const filteredDifferences = formattedDifferences.filter(diff => diff);
+
+    // Log the differences in a table format
+    if (filteredDifferences.length > 0) {
+        if (dryRun) {
+            logger(`Dry Run: Differences for database ${database}:`);
+        } else {
+            logger(`Differences applied for database ${database}:`);
+        }
+        console.table(filteredDifferences);
+    } else {
+        if (dryRun) {
+            logger(`Dry Run: No differences found. Database: ${database}`);
+        } else {
+            logger(`No differences found. Database: ${database}`);
+        }
+    }
 }

package/src/normalizers.js

@@ -1,6 +1,28 @@
-export const normalizeSQLDefinition = (definition) => {
-    return definition
-        .replace(/\s+/g, ' ') // Replace multiple whitespace with a single space
-        .replace(/'/g, "\\'") // Escape single quotes
-        .trim(); // Trim leading and trailing whitespace
-}
+/**
+ * Undo formatting that differs between MySQL versions but doesn't change the
+ * structure, so a template dumped from one version compares cleanly with
+ * another:
+ *   - integer display widths: int(11) in 5.7 is int from 8.0.19, except
+ *     tinyint(1) and ZEROFILL types, which keep them
+ *   - year(4) in 5.7 is year from 8.0.19
+ *   - utf8 is shown as utf8mb3 from 8.0.24 (fully from 8.0.30)
+ * Applies to column types and to procedure, trigger and view definitions.
+ */
+export const normalizeVersionFormatting = (sql) => {
+    if (typeof sql !== 'string') return sql;
+    return sql
+        .replace(/\b(tinyint|smallint|mediumint|int|integer|bigint)\((\d+)\)(\s+unsigned)?(?!\s+(?:unsigned\s+)?zerofill)/gi,
+            (match, type, width, unsigned = '') => type.toLowerCase() === 'tinyint' && width === '1' && !unsigned ? match : `${type}${unsigned}`)
+        .replace(/\byear\(4\)/gi, 'year')
+        .replace(/\butf8mb3(?=\b|_)/gi, 'utf8');
+}
+
+// A column type compared across MySQL versions
+export const normalizeColumnType = (type) => normalizeVersionFormatting(type);
+
+export const normalizeSQLDefinition = (definition) => {
+    return normalizeVersionFormatting(definition)
+        .replace(/\s+/g, ' ') // Replace multiple whitespace with a single space
+        .replace(/'/g, "\\'") // Escape single quotes
+        .trim(); // Trim leading and trailing whitespace
+}

package/src/options.js

@@ -0,0 +1,133 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * Optional file in the dump/template directory:
+ *
+ * {
+ *   "definer": "root@%",                     // DEFINER for every procedure, view and trigger
+ *   "autoIncrement": false,                  // default for every table
+ *   "databases": {
+ *     "Alerts": {
+ *       "AlarmRules": {
+ *         "autoIncrement": 1000,             // overrides the default for this table
+ *         "rowKey": ["idAlarmRule"],         // columns that identify a row; defaults to the primary key
+ *         "rows": [{ "idAlarmRule": 1, "name": "Default" }]
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * autoIncrement controls the table's AUTO_INCREMENT=N counter in CREATE TABLE
+ * (not the AUTO_INCREMENT column attribute):
+ *   true   keep the counter as dumped (the default)
+ *   false  remove it, so new tables start at 1
+ *   N      start new tables at N
+ *
+ * rows are inserted when no row with the same rowKey values exists; existing rows are never changed.
+ *
+ * definer replaces the DEFINER of every procedure, view and trigger in the
+ * template, so one whose database definer differs is reported and recreated
+ * with it. Written as root@%, `root`@`%` or 'root'@'%'.
+ */
+export const OPTIONS_FILE = 'syncOptions.json';
+
+export const loadSyncOptions = async (dir) => {
+    const filePath = path.join(dir, OPTIONS_FILE);
+    let content;
+    try {
+        content = await fs.readFile(filePath, 'utf-8');
+    } catch (err) {
+        if (err.code === 'ENOENT') return {};
+        throw err;
+    }
+    let options;
+    try {
+        options = JSON.parse(content);
+    } catch (err) {
+        throw new Error(`Invalid JSON in ${filePath}: ${err.message}`);
+    }
+    validateSyncOptions(options, filePath);
+    return options;
+}
+
+const isValidAutoIncrement = (value) => value === undefined || typeof value === 'boolean' || (Number.isInteger(value) && value > 0);
+
+const validateSyncOptions = (options, filePath) => {
+    if (options.definer !== undefined && formatDefiner(options.definer) === null) {
+        throw new Error(`${filePath}: definer must look like root@% or \`root\`@\`%\``);
+    }
+    if (!isValidAutoIncrement(options.autoIncrement)) {
+        throw new Error(`${filePath}: autoIncrement must be true, false or a positive integer`);
+    }
+    for (const [database, tables] of Object.entries(options.databases || {})) {
+        for (const [table, tableOptions] of Object.entries(tables || {})) {
+            const where = `${filePath}: ${database}.${table}`;
+            if (!isValidAutoIncrement(tableOptions.autoIncrement)) {
+                throw new Error(`${where}.autoIncrement must be true, false or a positive integer`);
+            }
+            if (tableOptions.rows !== undefined && (!Array.isArray(tableOptions.rows) || tableOptions.rows.some(row => !row || typeof row !== 'object' || Array.isArray(row)))) {
+                throw new Error(`${where}.rows must be an array of objects`);
+            }
+            if (tableOptions.rowKey !== undefined && (!Array.isArray(tableOptions.rowKey) || tableOptions.rowKey.length === 0)) {
+                throw new Error(`${where}.rowKey must be a non-empty array of column names`);
+            }
+        }
+    }
+}
+
+export const getTableOptions = (syncOptions, database, table) => ({
+    autoIncrement: syncOptions?.autoIncrement ?? true,
+    ...syncOptions?.databases?.[database]?.[table]
+});
+
+export const removeAutoIncrementCounter = (createSQL) => createSQL.replace(/\s+AUTO_INCREMENT=\d+/i, '');
+
+// Apply a table's autoIncrement option to its CREATE TABLE statement
+export const applyAutoIncrementOption = (createSQL, autoIncrement = true) => {
+    if (!createSQL || autoIncrement === true) return createSQL;
+    const withoutCounter = removeAutoIncrementCounter(createSQL);
+    if (autoIncrement === false) return withoutCounter;
+    if (/\)\s*ENGINE=\w+/i.test(withoutCounter)) {
+        return withoutCounter.replace(/(\)\s*ENGINE=\w+)/i, `$1 AUTO_INCREMENT=${autoIncrement}`);
+    }
+    return withoutCounter.replace(/\)(\s*;?\s*)$/, `) AUTO_INCREMENT=${autoIncrement}$1`);
+}
+
+// root@%, `root`@`%`, 'root'@'%' or DEFINER=... -> `root`@`%`; null if it isn't a user@host
+export const formatDefiner = (definer) => {
+    if (typeof definer !== 'string') return null;
+    const match = definer.trim().replace(/^DEFINER\s*=\s*/i, '')
+        .match(/^(?:`([^`]+)`|'([^']+)'|([^@`'\s]+))@(?:`([^`]+)`|'([^']+)'|([^@`'\s]+))$/);
+    if (!match) return null;
+    const user = match[1] ?? match[2] ?? match[3];
+    const host = match[4] ?? match[5] ?? match[6];
+    return `\`${user}\`@\`${host}\``;
+}
+
+// The DEFINER clause in a CREATE PROCEDURE/VIEW/TRIGGER header
+const definerClauseRegex = /DEFINER\s*=\s*(?:`[^`]*`|'[^']*'|[^\s@]+)@(?:`[^`]*`|'[^']*'|[^\s]+)/i;
+
+// Replace the DEFINER in one definition; unchanged when definer isn't set or the definition has none
+export const applyDefiner = (definition, definer) => {
+    const formatted = definer ? formatDefiner(definer) : null;
+    if (!formatted || typeof definition !== 'string') return definition;
+    return definition.replace(definerClauseRegex, `DEFINER=${formatted}`);
+}
+
+// A copy of a database structure with the definer option applied to its procedures, views and triggers
+export const applyDefinerOption = (structure, definer) => {
+    if (!definer || !structure) return structure;
+    const tables = Object.fromEntries(Object.entries(structure.tables || {}).map(([name, table]) => [name, {
+        ...table,
+        triggers: (table.triggers || []).map(trigger => ({ ...trigger, Definition: applyDefiner(trigger.Definition, definer) }))
+    }]));
+    const result = { ...structure, tables };
+    if (structure.procedures) {
+        result.procedures = structure.procedures.map(procedure => ({ ...procedure, Definition: applyDefiner(procedure.Definition, definer) }));
+    }
+    if (structure.views) {
+        result.views = Object.fromEntries(Object.entries(structure.views).map(([name, view]) => [name, applyDefiner(view, definer)]));
+    }
+    return result;
+}