mysqlsyncr 1.1.12 → 1.2.1

package/README.md

@@ -63,6 +63,9 @@ mysqlsyncr <command> [options]
 - `compare`: Compares the database structure with JSON dumps (dry run).
 - `update`: Updates the database structure based on JSON dumps.
 - `ui`: Opens a web-based database browser in your default system browser.
+- `rebuild`: Rebuilds each table's columns and indexes in the dump's JSON from its `CREATE TABLE` statement, and lists what changes. Dry run unless `--write` is given. Needs no database connection.
+
+Run `mysqlsyncr` with no command in a terminal and it asks for the command and its options (host, port, user, password, database and folder) instead. The password isn't shown as you type, and `update` asks for confirmation before changing anything.
 
 ### Configuration Options
 
@@ -79,6 +82,60 @@ You can configure the following options when running the commands:
 | `database`  | `-d`  | Target database                                                            | `null`                        |
 | `output`    | `-o`  | Output directory for dumping. Default is one level up from the current directory in a new folder called `db-dump` | `../db-dump`                  |
 | `verbose`   | `-v`  | Enable verbose logging (boolean)                                          | `false`                       |
+| `write`     |       | With `rebuild`, write the rebuilt files (boolean)                         | `false`                       |
+
+### Sync Options File
+
+Put a `syncOptions.json` file in the dump directory (next to the database folders) to control table creation and seed rows. It's optional; without it everything behaves as before.
+
+```json
+{
+  "definer": "root@%",
+  "autoIncrement": false,
+  "databases": {
+    "Alerts": {
+      "AlarmRules": {
+        "autoIncrement": 1000,
+        "rows": [
+          { "idAlarmRule": 1, "name": "Default rule" }
+        ]
+      },
+      "Settings": {
+        "rowKey": ["settingName"],
+        "rows": [
+          { "settingName": "emailEnabled", "value": "1" }
+        ]
+      }
+    }
+  }
+}
+```
+
+**`autoIncrement`** sets the table's `AUTO_INCREMENT=N` counter in `CREATE TABLE`. The `AUTO_INCREMENT` attribute on the id column is never changed. Set it at the top level as the default for every table, and per table to override it.
+
+| Value | Effect |
+|-------|--------|
+| `true` | Keep the counter as dumped (default) |
+| `false` | Remove the counter, so new tables start at 1 |
+| A number | Start new tables at that number |
+
+It applies when `dump` saves a table, when `update` creates a missing table, and when `rebuild` rewrites a template. The counter is always ignored when comparing tables.
+
+**`rows`** are seed rows. `compare` reports each row that isn't in the table as `missing_row`, and `update` inserts it after any table and column changes. A row counts as present when a row with the same `rowKey` values exists, so existing rows are never changed. `rowKey` defaults to the table's primary key; every row must include the key columns.
+
+**`definer`** sets the `DEFINER` of every stored procedure, view and trigger, written as `root@%` or `` `root`@`%` ``. The template's definers are replaced with it before comparing, so an object in the database with a different definer is reported and `update` recreates it with this one. `dump` and Keep Current in the UI also save it. The MySQL user running the sync needs the `SET_USER_ID` (or `SUPER`) privilege to create objects for another definer, and the definer user should exist.
+
+### MySQL Versions
+
+MySQL 5.7 and 8.0 print some definitions differently. These are formatting, not structure, so they're ignored when comparing tables, procedures, triggers and views:
+
+- Integer display widths: 5.7 prints `int(11)`, 8.0.19 and later print `int`. `tinyint(1)` and `ZEROFILL` types keep their width on both.
+- `YEAR(4)` is printed as `year` from 8.0.19.
+- `utf8` is printed as `utf8mb3` from 8.0.24 (fully from 8.0.30).
+
+`dump` records the server's version in `dumpInfo.json`. For templates dumped before that, the version is inferred from the SQL. `compare`, `update` and the UI show the template's and the server's versions and note what differs between them.
+
+When applying a template from 8.0 to a 5.7 server, the `utf8mb4_0900_*` collations 5.7 doesn't have are replaced with `utf8mb4_unicode_ci` (`utf8mb4_bin` for accent- or case-sensitive ones), and each substitution is reported as a warning. Applying also sets `explicit_defaults_for_timestamp` for the session, as 8.0 does by default. Expression defaults such as `DEFAULT (...)` need 8.0.13 or later and fail on 5.7.
 
 ### Example Usage
 
@@ -181,6 +238,8 @@ Contributions are welcome! If you would like to contribute to MySQLSyncr, please
 4. Push your changes to your forked repository.
 5. Open a pull request to the main repository.
 
+Before committing, run `npm test` and `npm run build`, which rebuilds `dist/` from `src/`. If you changed the UI (`ui/src`), also rebuild `ui/dist` with `npm run build` in `ui/`. That needs Node.js 22.22.0 or later; see [ui/README.md](ui/README.md). Running or installing mysqlsyncr has no such requirement.
+
 
 ## License
 

package/__tests__/acceptCurrent.test.js

@@ -0,0 +1,117 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { replaceCreateSQLElement, acceptCurrentIntoTemplate } from '../src/acceptCurrent';
+import { parseCreateTableSQL } from '../src/parsers';
+import { findDifferences } from '../src/differences';
+
+const templateSQL = `CREATE TABLE \`E2Data\` (
+  \`IID\` varchar(25) DEFAULT NULL,
+  \`DeviceId\` varchar(45) NOT NULL,
+  \`oldColumn\` int DEFAULT NULL,
+  PRIMARY KEY (\`IID\`),
+  KEY \`IndexIID\` (\`IID\`)
+) ENGINE=InnoDB DEFAULT CHARSET=latin1`;
+
+const liveSQL = `CREATE TABLE \`E2Data\` (
+  \`IID\` varchar(25) DEFAULT NULL,
+  \`DeviceId\` varchar(75) NOT NULL,
+  \`newColumn\` int NOT NULL DEFAULT '0',
+  PRIMARY KEY (\`IID\`),
+  KEY \`IndexIID\` (\`IID\`,\`DeviceId\`),
+  KEY \`idx_new\` (\`newColumn\`)
+) ENGINE=InnoDB AUTO_INCREMENT=55 DEFAULT CHARSET=latin1`;
+
+describe('replaceCreateSQLElement', () => {
+    test('replaces a changed column line', () => {
+        const result = replaceCreateSQLElement(templateSQL, liveSQL, 'col:DeviceId');
+        expect(result).toContain('  `DeviceId` varchar(75) NOT NULL,\n');
+        expect(result.split('\n')).toHaveLength(templateSQL.split('\n').length);
+    });
+
+    test('removes a column the database does not have', () => {
+        expect(replaceCreateSQLElement(templateSQL, liveSQL, 'col:oldColumn')).not.toContain('oldColumn');
+    });
+
+    test('adds a column after the one before it in the database', () => {
+        const result = replaceCreateSQLElement(templateSQL, liveSQL, 'col:newColumn');
+        expect(result).toContain("  `DeviceId` varchar(45) NOT NULL,\n  `newColumn` int NOT NULL DEFAULT '0',\n  `oldColumn`");
+    });
+
+    test('adds, replaces and removes indexes, keeping commas valid', () => {
+        let result = replaceCreateSQLElement(templateSQL, liveSQL, 'idx:idx_new');
+        expect(result).toContain('  KEY `IndexIID` (`IID`),\n  KEY `idx_new` (`newColumn`)\n) ENGINE');
+        result = replaceCreateSQLElement(result, liveSQL, 'idx:IndexIID');
+        expect(result).toContain('KEY `IndexIID` (`IID`,`DeviceId`),');
+        result = replaceCreateSQLElement(result, templateSQL, 'idx:idx_new');
+        expect(result).toContain('  KEY `IndexIID` (`IID`,`DeviceId`)\n) ENGINE');
+        expect(parseCreateTableSQL(result).indexes.map(i => i.Name)).toEqual(['PRIMARY', 'IndexIID']);
+    });
+
+    test('leaves the AUTO_INCREMENT counter of the template alone', () => {
+        expect(replaceCreateSQLElement(templateSQL, liveSQL, 'col:DeviceId')).not.toContain('AUTO_INCREMENT=');
+    });
+});
+
+describe('acceptCurrentIntoTemplate', () => {
+    // Answers the queries getDatabaseStructure makes for a database holding liveSQL
+    const liveConnection = () => ({
+        query: async (sql) => {
+            if (sql.startsWith('SHOW FULL TABLES WHERE')) return [{ Tables_in_db: 'E2Data' }];
+            if (sql.startsWith('SHOW CREATE TABLE')) return [{ 'Create Table': liveSQL }];
+            return [];
+        }
+    });
+
+    const writeTemplate = () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mysqlsyncr-accept-'));
+        fs.mkdirSync(path.join(dir, 'currentCOMPortData', 'tables'), { recursive: true });
+        const parsed = parseCreateTableSQL(templateSQL);
+        const template = {
+            tables: {
+                E2Data: { columns: parsed.columns, indexes: parsed.indexes, constraints: [], triggers: [], createSQL: templateSQL },
+                Dropped: { columns: [], indexes: [], constraints: [], triggers: [], createSQL: 'CREATE TABLE `Dropped` (\n  `a` int\n)' }
+            },
+            procedures: []
+        };
+        fs.writeFileSync(path.join(dir, 'currentCOMPortData', 'currentCOMPortData.json'), JSON.stringify(template));
+        fs.writeFileSync(path.join(dir, 'currentCOMPortData', 'tables', 'Dropped.sql'), 'x');
+        return dir;
+    };
+    const readTemplate = (dir) => JSON.parse(fs.readFileSync(path.join(dir, 'currentCOMPortData', 'currentCOMPortData.json'), 'utf-8'));
+
+    test('keeping every difference leaves none', async () => {
+        const dir = writeTemplate();
+        const live = { tables: { E2Data: { ...parseCreateTableSQL(liveSQL), triggers: [], createSQL: liveSQL } }, procedures: [] };
+        const diffs = findDifferences(readTemplate(dir), live);
+        expect(diffs.map(d => d.type).sort()).toEqual(['extra_field', 'extra_index', 'extra_index', 'missing_field', 'missing_table', 'mismatched_field'].sort());
+
+        await acceptCurrentIntoTemplate(liveConnection(), dir, 'currentCOMPortData', diffs);
+
+        const template = readTemplate(dir);
+        expect(findDifferences(template, live)).toEqual([]);
+        expect(template.tables.Dropped).toBeUndefined();
+        expect(fs.existsSync(path.join(dir, 'currentCOMPortData', 'tables', 'Dropped.sql'))).toBe(false);
+        expect(fs.readFileSync(path.join(dir, 'currentCOMPortData', 'tables', 'E2Data.sql'), 'utf-8')).toBe(`${template.tables.E2Data.createSQL}\n`);
+    });
+
+    test('only the chosen difference changes', async () => {
+        const dir = writeTemplate();
+        await acceptCurrentIntoTemplate(liveConnection(), dir, 'currentCOMPortData', [
+            { type: 'mismatched_field', info: 'Type', tableName: 'E2Data', field: { Field: 'DeviceId', Type: 'varchar(45)', NotNull: true } }
+        ]);
+        const table = readTemplate(dir).tables.E2Data;
+        expect(table.columns.map(c => c.Field)).toEqual(['IID', 'DeviceId', 'oldColumn']);
+        expect(table.columns[1].Type).toBe('varchar(75)');
+        expect(table.indexes.find(i => i.Name === 'IndexIID').ColumnName).toEqual(['IID']);
+    });
+
+    test('saves what it can and reports the rest', async () => {
+        const dir = writeTemplate();
+        await expect(acceptCurrentIntoTemplate(liveConnection(), dir, 'currentCOMPortData', [
+            { type: 'missing_row', tableName: 'E2Data', key: { IID: 'x' }, row: { IID: 'x' } },
+            { type: 'missing_table', tableName: 'Dropped' }
+        ])).rejects.toMatchObject({ errors: [{ difference: 'missing_row E2Data' }] });
+        expect(readTemplate(dir).tables.Dropped).toBeUndefined();
+    });
+});

package/__tests__/columnAttributes.test.js

@@ -0,0 +1,101 @@
+import { parseCreateTableSQL } from '../src/parsers';
+
+// Regression tests for column attributes rendered between the type and the
+// NULL/DEFAULT clauses. Before the fix these columns parsed with no Default and
+// no NotNull, which produced phantom `mismatched_field` differences whenever the
+// two sides of a compare rendered COLLATE differently. The parser also records
+// the collation, charset, unsigned and generated expression, so a column can be
+// restated without losing them.
+
+const columnOf = (sql, name) =>
+    parseCreateTableSQL(sql).columns.find(c => c.Field === name);
+
+describe('Column attributes between type and DEFAULT', () => {
+
+    test('COLLATE does not swallow DEFAULT NULL', () => {
+        const input = `CREATE TABLE \`E2Alarms\` (
+  \`IID\` varchar(25) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
+  PRIMARY KEY (\`IID\`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`;
+
+        expect(columnOf(input, 'IID')).toEqual({
+            Field: 'IID',
+            Type: 'varchar(25)',
+            Collate: 'utf8mb4_unicode_ci',
+            Default: 'NULL'
+        });
+    });
+
+    test('a collated column parses the same with or without the COLLATE clause, apart from the collation', () => {
+        const withCollate = `CREATE TABLE \`T\` (
+  \`point\` varchar(45) COLLATE utf8mb4_unicode_ci DEFAULT NULL
+)`;
+        const withoutCollate = `CREATE TABLE \`T\` (
+  \`point\` varchar(45) DEFAULT NULL
+)`;
+
+        const { Collate, ...rest } = columnOf(withCollate, 'point');
+        expect(Collate).toBe('utf8mb4_unicode_ci');
+        expect(rest).toEqual(columnOf(withoutCollate, 'point'));
+    });
+
+    test('CHARACTER SET and COLLATE together do not swallow NOT NULL or DEFAULT', () => {
+        const input = `CREATE TABLE \`T\` (
+  \`name\` varchar(45) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL DEFAULT 'x'
+)`;
+
+        expect(columnOf(input, 'name')).toEqual({
+            Field: 'name',
+            Type: 'varchar(45)',
+            Charset: 'utf8mb4',
+            Collate: 'utf8mb4_unicode_ci',
+            NotNull: true,
+            Default: 'x'
+        });
+    });
+
+    test('unsigned does not swallow NOT NULL, DEFAULT or AUTO_INCREMENT, and stays part of the type', () => {
+        const input = `CREATE TABLE \`T\` (
+  \`qty\` int(11) unsigned NOT NULL DEFAULT '0',
+  \`id\` bigint(20) unsigned NOT NULL AUTO_INCREMENT
+)`;
+
+        expect(columnOf(input, 'qty')).toEqual({
+            Field: 'qty',
+            Type: 'int(11) unsigned',
+            NotNull: true,
+            Default: '0'
+        });
+        expect(columnOf(input, 'id')).toEqual({
+            Field: 'id',
+            Type: 'bigint(20) unsigned',
+            NotNull: true,
+            AutoIncrement: true
+        });
+    });
+
+    test('a collated column with no DEFAULT still parses without one', () => {
+        const input = `CREATE TABLE \`T\` (
+  \`alarmString\` text COLLATE utf8mb4_unicode_ci
+)`;
+
+        expect(columnOf(input, 'alarmString')).toEqual({
+            Field: 'alarmString',
+            Type: 'text',
+            Collate: 'utf8mb4_unicode_ci'
+        });
+    });
+
+    test('a collated generated column is not given a DEFAULT', () => {
+        const input = `CREATE TABLE \`T\` (
+  \`computed_tablename\` varchar(255) COLLATE utf8mb4_unicode_ci GENERATED ALWAYS AS (concat(_utf8mb4'E2Data||',\`IID\`,_utf8mb4'||',\`point\`)) STORED
+)`;
+
+        expect(columnOf(input, 'computed_tablename')).toEqual({
+            Field: 'computed_tablename',
+            Type: 'varchar(255)',
+            Collate: 'utf8mb4_unicode_ci',
+            Generated: "(concat(_utf8mb4'E2Data||',`IID`,_utf8mb4'||',`point`)) STORED"
+        });
+    });
+});

package/__tests__/options.test.js

@@ -0,0 +1,259 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { applyAutoIncrementOption, getTableOptions, loadSyncOptions, OPTIONS_FILE } from '../src/options';
+import { findDifferences } from '../src/differences';
+import { findMissingRows } from '../src/rows';
+import { applyDifferences } from '../src/apply';
+import { rebuildTemplate } from '../src/rebuild';
+import { parseCreateTableSQL } from '../src/parsers';
+
+const createSQL = `CREATE TABLE \`AlarmRules\` (
+  \`idAlarmRule\` int NOT NULL AUTO_INCREMENT,
+  \`name\` varchar(45) NOT NULL DEFAULT 'System Generated',
+  PRIMARY KEY (\`idAlarmRule\`)
+) ENGINE=InnoDB AUTO_INCREMENT=400101 DEFAULT CHARSET=latin1`;
+
+const tempDir = () => fs.mkdtempSync(path.join(os.tmpdir(), 'mysqlsyncr-'));
+
+describe('applyAutoIncrementOption', () => {
+    test('true keeps the counter', () => {
+        expect(applyAutoIncrementOption(createSQL, true)).toBe(createSQL);
+    });
+
+    test('false removes the counter but not the column attribute', () => {
+        const result = applyAutoIncrementOption(createSQL, false);
+        expect(result).not.toContain('AUTO_INCREMENT=');
+        expect(result).toContain('`idAlarmRule` int NOT NULL AUTO_INCREMENT,');
+        expect(result).toContain(') ENGINE=InnoDB DEFAULT CHARSET=latin1');
+    });
+
+    test('a number sets the counter', () => {
+        expect(applyAutoIncrementOption(createSQL, 1000)).toContain(') ENGINE=InnoDB AUTO_INCREMENT=1000 DEFAULT CHARSET=latin1');
+        expect(applyAutoIncrementOption('CREATE TABLE `t` (\n  `id` int\n);', 5)).toBe('CREATE TABLE `t` (\n  `id` int\n) AUTO_INCREMENT=5;');
+    });
+});
+
+describe('sync options file', () => {
+    test('a missing file means no options', async () => {
+        expect(await loadSyncOptions(tempDir())).toEqual({});
+    });
+
+    test('table options override the default', () => {
+        const options = { autoIncrement: false, databases: { Alerts: { AlarmRules: { autoIncrement: 1000 } } } };
+        expect(getTableOptions(options, 'Alerts', 'AlarmRules').autoIncrement).toBe(1000);
+        expect(getTableOptions(options, 'Alerts', 'Other').autoIncrement).toBe(false);
+        expect(getTableOptions({}, 'Alerts', 'Other').autoIncrement).toBe(true);
+    });
+
+    test('rejects invalid values', async () => {
+        const dir = tempDir();
+        fs.writeFileSync(path.join(dir, OPTIONS_FILE), JSON.stringify({ databases: { Alerts: { AlarmRules: { autoIncrement: 'yes' } } } }));
+        await expect(loadSyncOptions(dir)).rejects.toThrow('Alerts.AlarmRules.autoIncrement');
+        fs.writeFileSync(path.join(dir, OPTIONS_FILE), JSON.stringify({ databases: { Alerts: { AlarmRules: { rows: { id: 1 } } } } }));
+        await expect(loadSyncOptions(dir)).rejects.toThrow('rows must be an array');
+    });
+});
+
+describe('missing_table with the autoIncrement option', () => {
+    const template = { tables: { AlarmRules: { ...parseCreateTableSQL(createSQL), triggers: [], createSQL } }, procedures: [] };
+    const empty = { tables: {}, procedures: [] };
+
+    test('creates the table without the dumped counter', () => {
+        const [diff] = findDifferences(template, empty, () => ({ autoIncrement: false }));
+        expect(diff.type).toBe('missing_table');
+        expect(diff.createSQL).not.toContain('AUTO_INCREMENT=');
+    });
+
+    test('tables differing only by counter match', () => {
+        const live = { tables: { AlarmRules: { ...template.tables.AlarmRules, createSQL: createSQL.replace('400101', '7') } }, procedures: [] };
+        expect(findDifferences(template, live)).toEqual([]);
+    });
+});
+
+describe('seed rows', () => {
+    const expected = { tables: { AlarmRules: parseCreateTableSQL(createSQL) } };
+    const options = { databases: { Alerts: { AlarmRules: { rows: [{ idAlarmRule: 1, name: 'Default' }, { idAlarmRule: 2, name: 'Other' }] } } } };
+
+    test('reports only rows whose primary key is not found', async () => {
+        const queries = [];
+        const connection = {
+            query: async (sql, values) => {
+                queries.push({ sql, values });
+                return values[0] === 1 ? [{ 1: 1 }] : [];
+            }
+        };
+        const diffs = await findMissingRows(connection, 'Alerts', expected, expected, options);
+        expect(queries[0]).toEqual({ sql: 'SELECT 1 FROM `Alerts`.`AlarmRules` WHERE `idAlarmRule` = ? LIMIT 1', values: [1] });
+        expect(diffs).toEqual([{ type: 'missing_row', tableName: 'AlarmRules', key: { idAlarmRule: 2 }, row: { idAlarmRule: 2, name: 'Other' } }]);
+    });
+
+    test('every row is missing when the table is missing, without querying it', async () => {
+        const connection = { query: jest.fn() };
+        const diffs = await findMissingRows(connection, 'Alerts', expected, { tables: {} }, options);
+        expect(diffs).toHaveLength(2);
+        expect(connection.query).not.toHaveBeenCalled();
+    });
+
+    test('uses rowKey and requires it on each row', async () => {
+        const keyed = { databases: { Alerts: { AlarmRules: { rowKey: ['name'], rows: [{ name: 'Default' }] } } } };
+        const connection = { query: async () => [] };
+        const [diff] = await findMissingRows(connection, 'Alerts', expected, expected, keyed);
+        expect(diff.key).toEqual({ name: 'Default' });
+        const bad = { databases: { Alerts: { AlarmRules: { rows: [{ name: 'Default' }] } } } };
+        await expect(findMissingRows(connection, 'Alerts', expected, expected, bad)).rejects.toThrow('missing rowKey column(s) idAlarmRule');
+    });
+
+    test('rows are inserted after the table is created', async () => {
+        const statements = [];
+        const connection = { query: async (sql, values) => { if (!sql.startsWith('USE') && !sql.startsWith('SELECT VERSION') && !sql.startsWith('SET SESSION')) statements.push({ sql, values }); return []; } };
+        await applyDifferences(connection, 'Alerts', [
+            { type: 'missing_row', tableName: 'AlarmRules', key: { idAlarmRule: 1 }, row: { idAlarmRule: 1, name: "it's" } },
+            { type: 'missing_table', tableName: 'AlarmRules', createSQL: 'CREATE TABLE ...' }
+        ]);
+        expect(statements).toEqual([
+            { sql: 'CREATE TABLE ...', values: undefined },
+            { sql: 'INSERT INTO `AlarmRules` (`idAlarmRule`, `name`) VALUES (?, ?);', values: [1, "it's"] }
+        ]);
+    });
+});
+
+describe('rebuildTemplate', () => {
+    const writeTemplate = (dir, table) => {
+        fs.mkdirSync(path.join(dir, 'Alerts', 'tables'), { recursive: true });
+        fs.writeFileSync(path.join(dir, 'Alerts', 'Alerts.json'), JSON.stringify({ tables: { AlarmRules: table } }));
+        fs.writeFileSync(path.join(dir, 'Alerts', 'tables', 'AlarmRules.sql'), `${table.createSQL}\n`);
+    };
+    // what the old parser produced: the default cut at the space
+    const oldTable = () => ({
+        columns: [
+            { Field: 'idAlarmRule', Type: 'int', NotNull: true, AutoIncrement: true },
+            { Field: 'name', Type: 'varchar(45)', NotNull: true, Default: 'System' }
+        ],
+        indexes: [{ ColumnName: ['idAlarmRule'], Primary: true, Name: 'PRIMARY' }],
+        triggers: [],
+        createSQL
+    });
+
+    test('dry run reports changes without writing', async () => {
+        const dir = tempDir();
+        writeTemplate(dir, oldTable());
+        const before = fs.readFileSync(path.join(dir, 'Alerts', 'Alerts.json'), 'utf-8');
+        const { changes: report } = await rebuildTemplate(dir);
+        expect(report['Alerts.AlarmRules']).toEqual([
+            'column name: JSON {"Type":"varchar(45)","NotNull":true,"Default":"System"} -> createSQL {"Type":"varchar(45)","NotNull":true,"Default":"System Generated"}'
+        ]);
+        expect(fs.readFileSync(path.join(dir, 'Alerts', 'Alerts.json'), 'utf-8')).toBe(before);
+    });
+
+    test('--write rebuilds the JSON and applies the autoIncrement option', async () => {
+        const dir = tempDir();
+        writeTemplate(dir, oldTable());
+        fs.writeFileSync(path.join(dir, OPTIONS_FILE), JSON.stringify({ autoIncrement: false }));
+        await rebuildTemplate(dir, { write: true });
+        const table = JSON.parse(fs.readFileSync(path.join(dir, 'Alerts', 'Alerts.json'), 'utf-8')).tables.AlarmRules;
+        expect(table.columns[1].Default).toBe('System Generated');
+        expect(table.createSQL).not.toContain('AUTO_INCREMENT=');
+        expect(table.triggers).toEqual([]);
+        expect(fs.readFileSync(path.join(dir, 'Alerts', 'tables', 'AlarmRules.sql'), 'utf-8')).not.toContain('AUTO_INCREMENT=');
+        expect((await rebuildTemplate(dir)).changes).toEqual({});
+    });
+});
+
+describe('definer option', () => {
+    const { formatDefiner, applyDefiner, applyDefinerOption } = require('../src/options');
+    const procedure = 'CREATE DEFINER=`neelands`@`localhost` PROCEDURE `P`()\nBEGIN\n  SELECT 1;\nEND';
+
+    test('accepts the usual ways of writing user@host', () => {
+        expect(formatDefiner('root@%')).toBe('`root`@`%`');
+        expect(formatDefiner("'root'@'localhost'")).toBe('`root`@`localhost`');
+        expect(formatDefiner('DEFINER=`root`@`%`')).toBe('`root`@`%`');
+        expect(formatDefiner('root')).toBeNull();
+    });
+
+    test('rejects an invalid definer in the options file', async () => {
+        const dir = tempDir();
+        fs.writeFileSync(path.join(dir, OPTIONS_FILE), JSON.stringify({ definer: 'root' }));
+        await expect(loadSyncOptions(dir)).rejects.toThrow('definer must look like');
+    });
+
+    test('replaces only the DEFINER clause', () => {
+        expect(applyDefiner(procedure, 'root@%')).toBe(procedure.replace('`neelands`@`localhost`', '`root`@`%`'));
+        const view = 'CREATE ALGORITHM=UNDEFINED DEFINER=`a`@`b` SQL SECURITY DEFINER VIEW `v` AS select 1';
+        expect(applyDefiner(view, 'root@%')).toBe('CREATE ALGORITHM=UNDEFINED DEFINER=`root`@`%` SQL SECURITY DEFINER VIEW `v` AS select 1');
+        expect(applyDefiner(procedure, undefined)).toBe(procedure);
+    });
+
+    test('applies to procedures, views and triggers without changing the original', () => {
+        const structure = {
+            tables: { t: { columns: [], indexes: [], triggers: [{ Name: 'trg', Definition: 'CREATE DEFINER=`x`@`y` TRIGGER `trg` BEFORE INSERT ON `t` FOR EACH ROW SET @a = 1' }] } },
+            procedures: [{ Name: 'P', Definition: procedure }],
+            views: { v: 'CREATE DEFINER=`x`@`y` VIEW `v` AS select 1' }
+        };
+        const result = applyDefinerOption(structure, 'root@%');
+        expect(result.procedures[0].Definition).toContain('DEFINER=`root`@`%`');
+        expect(result.views.v).toContain('DEFINER=`root`@`%`');
+        expect(result.tables.t.triggers[0].Definition).toContain('DEFINER=`root`@`%`');
+        expect(structure.procedures[0].Definition).toBe(procedure);
+    });
+
+    test('a database object with another definer is reported, and one with the option definer is not', () => {
+        const template = applyDefinerOption({ tables: {}, procedures: [{ Name: 'P', Definition: procedure }] }, 'root@%');
+        const differentDefiner = { tables: {}, procedures: [{ Name: 'P', Definition: procedure }] };
+        const sameDefiner = { tables: {}, procedures: [{ Name: 'P', Definition: applyDefiner(procedure, 'root@%') }] };
+        const [diff] = findDifferences(template, differentDefiner);
+        expect(diff).toMatchObject({ type: 'mismatched_procedure', Definition: applyDefiner(procedure, 'root@%') });
+        expect(findDifferences(template, sameDefiner)).toEqual([]);
+    });
+});
+
+describe('trigger comparison', () => {
+    const table = (definition) => ({
+        tables: { t: { columns: [], indexes: [], triggers: [{ Name: 'trg', Definition: definition }], createSQL: 'CREATE TABLE `t` (\n  `a` int\n)' } },
+        procedures: []
+    });
+    const trigger = 'CREATE DEFINER=`root`@`%` TRIGGER `trg` BEFORE INSERT ON `t` FOR EACH ROW SET NEW.a = 1';
+
+    test('a changed trigger body is reported with both definitions', () => {
+        const diffs = findDifferences(table(trigger), table(trigger.replace('= 1', '= 2')));
+        expect(diffs).toHaveLength(1);
+        expect(diffs[0]).toMatchObject({ type: 'mismatched_trigger', trigger: { Definition: trigger }, currentTrigger: { Definition: trigger.replace('= 1', '= 2') } });
+    });
+
+    test('whitespace-only changes are not', () => {
+        expect(findDifferences(table(trigger), table(trigger.replace(' FOR EACH', '\n  FOR   EACH')))).toEqual([]);
+    });
+});
+
+describe('rebuildTemplate and tables/*.sql', () => {
+    const setup = (sqlFile) => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mysqlsyncr-'));
+        fs.mkdirSync(path.join(dir, 'Alerts', 'tables'), { recursive: true });
+        const clean = createSQL.replace(' AUTO_INCREMENT=400101', '');
+        const parsed = parseCreateTableSQL(clean);
+        fs.writeFileSync(path.join(dir, 'Alerts', 'Alerts.json'), JSON.stringify({ tables: { AlarmRules: { columns: parsed.columns, indexes: parsed.indexes, constraints: [], triggers: [], createSQL: clean } } }));
+        fs.writeFileSync(path.join(dir, OPTIONS_FILE), JSON.stringify({ autoIncrement: false }));
+        fs.writeFileSync(path.join(dir, 'Alerts', 'tables', 'AlarmRules.sql'), sqlFile);
+        return { dir, clean, read: () => fs.readFileSync(path.join(dir, 'Alerts', 'tables', 'AlarmRules.sql'), 'utf-8'), json: () => fs.readFileSync(path.join(dir, 'Alerts', 'Alerts.json'), 'utf-8') };
+    };
+
+    test('only the counter is removed from a .sql file, keeping notes written in it', async () => {
+        const notes = '\n-- Notes about these columns, written by hand\n';
+        const { dir, clean, read, json } = setup(`${createSQL};\n${notes}`);
+        const jsonBefore = json();
+        expect((await rebuildTemplate(dir)).changes).toEqual({ 'Alerts.AlarmRules': ['tables/AlarmRules.sql: AUTO_INCREMENT counter changed by the autoIncrement option'] });
+        await rebuildTemplate(dir, { write: true });
+        expect(read()).toBe(`${clean};\n${notes}`);
+        expect(json()).toBe(jsonBefore);
+        expect(await rebuildTemplate(dir)).toMatchObject({ changes: {} });
+    });
+
+    test('other differences in a .sql file are reported, not overwritten', async () => {
+        const edited = createSQL.replace(' AUTO_INCREMENT=400101', '').replace('  PRIMARY KEY', '  `extra` int DEFAULT NULL,\n  PRIMARY KEY');
+        const { dir, read } = setup(`${edited}\n`);
+        const { changes, notes } = await rebuildTemplate(dir, { write: true });
+        expect(changes).toEqual({});
+        expect(notes['Alerts.AlarmRules']).toContain('differs from the createSQL');
+        expect(read()).toBe(`${edited}\n`);
+    });
+});