mysqlsyncr 1.1.10 → 1.2.1

package/README.md

@@ -1,186 +1,246 @@
-# MySQLSyncr
-
-Warning: Please be careful when using this tool. It is still in development and may not be fully stable. Test on a development database before using on production.
-
-MySQLSyncr is a command-line tool for managing and comparing MySQL database structures with JSON dumps. It allows users to dump the database structure, compare it with existing JSON files, and update the database based on those JSON definitions.
-
-## Table of Contents
-
-- [Features](#features)
-- [Installation](#installation)
-  - [Global Installation](#global-installation)
-  - [Local Installation](#local-installation)
-- [Usage](#usage)
-  - [Commands](#commands)
-  - [Configuration Options](#configuration-options)
-- [Using MySQLSyncr as a Module](#using-mysqlsyncr-as-a-module)
-- [Contributing](#contributing)
-- [License](#license)
-
-## Features
-
-- **Dump**: Export the database structure to JSON files.
-- **Compare**: Compare the current database structure with JSON dumps to identify differences.
-- **Update**: Update the database structure based on the provided JSON definitions.
-- **UI**: Open a web-based database browser interface.
-- **Verbose Logging**: Enable detailed logging for debugging purposes.
-
-![Database Browser Interface](view.png)
-
-## Installation
-
-### Global Installation
-
-To install MySQLSync globally, allowing you to use it from the command line, run the following command:
-
-```bash
-npm install -g mysqlsyncr
-```
-
-This will allow you to run the command as `mysqlsyncr` from anywhere in your terminal.
-
-### Local Installation
-
-If you prefer to use MySQLSyncr locally within a project, you can install it as a dependency:
-
-```bash
-npm install mysqlsyncr
-```
-
-This will add MySQLSyncr to your project's `node_modules` and allow you to use it within your project.
-
-## Usage
-
-You can run MySQLSync commands using the following syntax:
-
-```bash
-mysqlsyncr <command> [options]
-```
-
-### Commands
-
-- `dump`: Dumps the database structure to files.
-- `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.
-
-### Configuration Options
-
-You can configure the following options when running the commands:
-
-| Option      | Alias | Description                                                                 | Default Value                  |
-|-------------|-------|-----------------------------------------------------------------------------|--------------------------------|
-| `uiPort`    | `-U`  | UI port                                                                     | `3600`                         |
-| `openUI`    | `-O`  | Open UI in default browser (boolean)                                      | `true`                         |
-| `host`      | `-h`  | Database host                                                              | `localhost`                   |
-| `port`      | `-P`  | Database port                                                              | `3306`                         |
-| `user`      | `-u`  | Database user                                                              | `root`                         |
-| `password`  | `-p`  | Database password (required)                                              |                                |
-| `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`                       |
-
-### Example Usage
-
-1. **Dump the database structure**:
-   ```bash
-   mysqlsyncr dump --host localhost --user root --password yourpassword
-   ```
-
-2. **Compare the database structure with JSON dumps**:
-   ```bash
-   mysqlsyncr compare --host localhost --user root --password yourpassword
-   ```
-
-3. **Update the database structure based on JSON dumps**:
-   ```bash
-   mysqlsyncr update --host localhost --user root --password yourpassword
-   ```
-
-4. **Open the database browser interface**:
-   ```bash
-   mysqlsyncr ui --host localhost --user root --password yourpassword
-   ```
-
-## Using MySQLSync as a Module
-
-If you want to use MySQLSync as a module in your own Node.js application, you can require it in your code:
-
-```javascript
-import mysqlsyncr from 'mysqlsyncr';
-
-// Example usage
-const config = {
-    host: 'localhost',
-    user: 'root',
-    password: 'yourpassword',
-    database: 'yourdatabase'
-};
-```
-
-```javascript
-// app.js
-import mysqlsyncr from 'mysqlsyncr';
-import fs from 'fs';
-import path from 'path';
-
-// Database configuration
-const config = {
-    host: 'localhost',
-    user: 'root',
-    password: 'yourpassword',
-    database: 'yourdatabase'
-};
-
-// Function to dump the database structure
-async function dumpDatabase() {
-    try {
-        console.log('Dumping the database structure...');
-        await mysqlsyncr.dump(config);
-        console.log('Database structure dumped successfully.');
-    } catch (error) {
-        console.error('Error dumping database:', error.message);
-    }
-}
-
-// Function to compare the database structure with JSON dumps
-async function compareDatabase() {
-    try {
-        const inputDir = path.join(__dirname, 'db-dump'); // Directory where JSON dumps are stored
-        console.log('Comparing the database structure with JSON dumps...');
-        const differences = await mysqlsyncr.compare(config, inputDir);
-        
-        if (differences.length > 0) {
-            console.log('Differences found:');
-            console.log(differences);
-        } else {
-            console.log('No differences found. The database structure matches the JSON dumps.');
-        }
-    } catch (error) {
-        console.error('Error comparing database:', error.message);
-    }
-}
-
-// Main function to execute dump and compare
-(async () => {
-    await dumpDatabase();
-    await compareDatabase();
-})();
-```
-
-Make sure to check the source code for available functions and their usage.
-
-## Contributing
-
-Contributions are welcome! If you would like to contribute to MySQLSyncr, please follow these steps:
-
-1. Fork the repository.
-2. Create a new branch for your feature or bug fix.
-3. Make your changes and commit them with clear messages.
-4. Push your changes to your forked repository.
-5. Open a pull request to the main repository.
-
-
-## License
-
-This project is licensed under the ISC License. See the [LICENSE](LICENSE) file for more details.
+# MySQLSyncr
+
+Warning: Please be careful when using this tool. It is still in development and may not be fully stable. Test on a development database before using on production.
+
+MySQLSyncr is a command-line tool for managing and comparing MySQL database structures with JSON dumps. It allows users to dump the database structure, compare it with existing JSON files, and update the database based on those JSON definitions.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+  - [Global Installation](#global-installation)
+  - [Local Installation](#local-installation)
+- [Usage](#usage)
+  - [Commands](#commands)
+  - [Configuration Options](#configuration-options)
+- [Using MySQLSyncr as a Module](#using-mysqlsyncr-as-a-module)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Features
+
+- **Dump**: Export the database structure to JSON files.
+- **Compare**: Compare the current database structure with JSON dumps to identify differences.
+- **Update**: Update the database structure based on the provided JSON definitions.
+- **UI**: Open a web-based database browser interface.
+- **Verbose Logging**: Enable detailed logging for debugging purposes.
+
+![Database Browser Interface](view.png)
+
+## Installation
+
+### Global Installation
+
+To install MySQLSync globally, allowing you to use it from the command line, run the following command:
+
+```bash
+npm install -g mysqlsyncr
+```
+
+This will allow you to run the command as `mysqlsyncr` from anywhere in your terminal.
+
+### Local Installation
+
+If you prefer to use MySQLSyncr locally within a project, you can install it as a dependency:
+
+```bash
+npm install mysqlsyncr
+```
+
+This will add MySQLSyncr to your project's `node_modules` and allow you to use it within your project.
+
+## Usage
+
+You can run MySQLSync commands using the following syntax:
+
+```bash
+mysqlsyncr <command> [options]
+```
+
+### Commands
+
+- `dump`: Dumps the database structure to files.
+- `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
+
+You can configure the following options when running the commands:
+
+| Option      | Alias | Description                                                                 | Default Value                  |
+|-------------|-------|-----------------------------------------------------------------------------|--------------------------------|
+| `uiPort`    | `-U`  | UI port                                                                     | `3600`                         |
+| `openUI`    | `-O`  | Open UI in default browser (boolean)                                      | `true`                         |
+| `host`      | `-h`  | Database host                                                              | `localhost`                   |
+| `port`      | `-P`  | Database port                                                              | `3306`                         |
+| `user`      | `-u`  | Database user                                                              | `root`                         |
+| `password`  | `-p`  | Database password (required)                                              |                                |
+| `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
+
+1. **Dump the database structure**:
+   ```bash
+   mysqlsyncr dump --host localhost --user root --password yourpassword
+   ```
+
+2. **Compare the database structure with JSON dumps**:
+   ```bash
+   mysqlsyncr compare --host localhost --user root --password yourpassword
+   ```
+
+3. **Update the database structure based on JSON dumps**:
+   ```bash
+   mysqlsyncr update --host localhost --user root --password yourpassword
+   ```
+
+4. **Open the database browser interface**:
+   *Note: This does not work with PowerShell. Must use Command Prompt in windows*
+   ```bash
+   mysqlsyncr ui --host localhost --user root --password yourpassword
+   ```
+
+## Using MySQLSync as a Module
+
+If you want to use MySQLSync as a module in your own Node.js application, you can require it in your code:
+
+```javascript
+import mysqlsyncr from 'mysqlsyncr';
+
+// Example usage
+const config = {
+    host: 'localhost',
+    user: 'root',
+    password: 'yourpassword',
+    database: 'yourdatabase'
+};
+```
+
+```javascript
+// app.js
+import mysqlsyncr from 'mysqlsyncr';
+import fs from 'fs';
+import path from 'path';
+
+// Database configuration
+const config = {
+    host: 'localhost',
+    user: 'root',
+    password: 'yourpassword',
+    database: 'yourdatabase'
+};
+
+// Function to dump the database structure
+async function dumpDatabase() {
+    try {
+        console.log('Dumping the database structure...');
+        await mysqlsyncr.dump(config);
+        console.log('Database structure dumped successfully.');
+    } catch (error) {
+        console.error('Error dumping database:', error.message);
+    }
+}
+
+// Function to compare the database structure with JSON dumps
+async function compareDatabase() {
+    try {
+        const inputDir = path.join(__dirname, 'db-dump'); // Directory where JSON dumps are stored
+        console.log('Comparing the database structure with JSON dumps...');
+        const differences = await mysqlsyncr.compare(config, inputDir);
+        
+        if (differences.length > 0) {
+            console.log('Differences found:');
+            console.log(differences);
+        } else {
+            console.log('No differences found. The database structure matches the JSON dumps.');
+        }
+    } catch (error) {
+        console.error('Error comparing database:', error.message);
+    }
+}
+
+// Main function to execute dump and compare
+(async () => {
+    await dumpDatabase();
+    await compareDatabase();
+})();
+```
+
+Make sure to check the source code for available functions and their usage.
+
+## Contributing
+
+Contributions are welcome! If you would like to contribute to MySQLSyncr, please follow these steps:
+
+1. Fork the repository.
+2. Create a new branch for your feature or bug fix.
+3. Make your changes and commit them with clear messages.
+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
+
+This project is licensed under the ISC License. See the [LICENSE](LICENSE) file for more details.

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