mysqlsyncr 1.1.12 → 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;
+}

package/src/parsers.js

@@ -11,9 +11,6 @@ export const parseCreateTableSQL = (createTableSQL) => {
     // 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_Old = /(PRIMARY|UNIQUE)?\s*KEY\s*`([^`]+)`\s*\(([^)]+)\)|PRIMARY KEY\s*\(([^)]+)\)/;
 
@@ -30,35 +27,12 @@ export const parseCreateTableSQL = (createTableSQL) => {
         if (line.includes('CREATE TABLE')) {
             continue;
         }
-        // Check if the line contains a column definition
-        const columnMatch = columnRegex.exec(line);
+        // Column definitions are the only lines that start with a backticked name
+        const column = parseColumnDefinition(line);
         const indexMatch = indexRegex.exec(line);
-        const indexMatch_Old = indexRegex_Old.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
-            }
-
+        if (column) {
             columns.push(column);
         } else if (indexMatch && !constraintMatch) {
 
@@ -141,11 +115,83 @@ export const parseConstraint = (sql) => {
     };
 };
 
-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
+// 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.`;
+}