@verdnatura/myt 1.5.1

package/.dockerignore

@@ -0,0 +1,2 @@
+node_modules
+.git

package/LICENSE

@@ -0,0 +1,17 @@
+Copyright (C) 2020 - Verdnatura Levante S.L.
+
+This package is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+On Debian systems, the complete text of the GNU General Public
+License can be found in "/usr/share/common-licenses/GPL-3".

package/README.md

@@ -0,0 +1,268 @@
+# Myt (MySQL Version Control)
+
+Utilities to ease the maintenance of MySQL or MariaDB database versioning using
+a Git repository.
+
+This project is just to bring an idea to life and is still in an early stage of
+development, so any help is welcomed! Feel free to contribute.
+
+## Requirements
+
+* Git
+* Docker (Optional, used to manage local server)
+
+## Installation
+
+It's recommended to install the package globally.
+
+```text
+# npm install -g myt
+$ myt <command>
+```
+
+You can also install locally and use the *npx* command to execute it.
+
+```text
+$ npm install myt
+$ npx myt <command>
+```
+
+## How to use
+
+Execute *myt* with the desired command.
+
+```text
+$ [npx] myt [-w|--workspace <string>] [-r|--remote <string>] [-d|--debug]
+[-h|--help] <command> [<args>]
+```
+
+The default workspace directory is the current working directory and unless 
+otherwise indicated, the default remote is *local*.
+
+Database versioning commands:
+
+ * **init**: Initialize an empty workspace.
+ * **pull**: Incorporate database routine changes into workspace.
+ * **push**: Apply changes into database.
+ * **version**: Creates a new version.
+
+Local server management commands:
+
+ * **dump**: Export database structure and fixtures.
+ * **fixtures**: Export local database fixtures.
+ * **run**: Build and start local database server container.
+ * **start**: Start local database server container.
+
+Each command can have its own specific commandline options.
+
+## Basic information
+
+First of all you have to initalize the workspace.
+
+```text
+$ myt init
+```
+
+Now you can configure Myt using *myt.config.yml* file, located at the root of
+your workspace. This file should include the project codename and schemas/tables
+wich are exported when you use *pull* or *dump* commands.
+
+Don't forget to initialize git (if it isn't initialized yet).
+
+```text
+$ git init
+```
+
+### Remotes
+
+Create database connection configuration for each environment at *remotes*
+folder using standard MySQL *ini* configuration files. The convention remote
+names are *local*, *production* and *test*.
+
+```text
+remotes/[remote].ini
+```
+### Startup
+
+Once the basic configuration is done, routines can be imported from the
+database into the project, it is recommended to use the *production* remote.
+
+```text
+$ myt pull production
+```
+
+From now on, you can use the project as if it were a standard git repository
+(since it is). To apply changes to the database run the *push* command on the
+desired remote.
+
+```text
+$ myt push [<remote>] [--commit]
+```
+
+### Routines
+
+Routines are placed inside *routines* folder. All objects that have PL/SQL code 
+are considered routines. It includes events, functions, procedures, triggers 
+and views with the following structure.
+
+```text
+  routines
+  `- schema
+     |- events
+     |  `- eventName.sql
+     |- functions
+     |  `- functionName.sql
+     |- procedures
+     |  `- procedureName.sql
+     |- triggers
+     |  `- triggerName.sql
+     `- views
+        `- viewName.sql
+```
+
+### Versions
+
+Versions are placed inside *versions* folder with the following structure.
+Don't place your PL/SQL objects here, use the routines folder!
+
+```text
+  versions
+  |- 00001-firstVersionCodeName
+  |  |- 00-firstExecutedScript.sql
+  |  |- 01-secondScript.sql
+  |  `- 99-lastScript.sql
+  `- 00002-secondVersion
+     |- 00-firstExecutedScript.sql
+     `- 00-sameNumbers.sql
+```
+
+### Local server
+
+The local server is created as a MariaDB Docker container using the base dump 
+created with the *dump* command plus pushing local versions and changed 
+routines.
+
+### Dumps
+
+You can create your local fixture and structure files.
+
+* *dump/beforeDump.sql*
+* *dump/afterDump.sql*
+* *dump/fixtures.sql*
+
+## Versioning commands
+
+### init
+
+Initializes an empty workspace.
+
+```text
+$ myt init
+```
+
+### pull
+
+Incorporates database routine changes into workspace.
+
+```text
+$ myt pull [remote] [-f|--force] [-c|--checkout] [-u|--update] [-s|--sums]
+```
+
+When *--checkout* option is provided, it does the following before export:
+
+1. Get the last database push commit (saved in versioning tables).
+2. Creates and checkout to a new branch based in database commit.
+
+### push
+
+Applies versions and routine changes into database.
+
+```text
+$ myt push [<remote>] [-f|--force] [-c|--commit] [-s|--sums]
+```
+
+Commit is saved into database only if *--commit* option is provided, it
+prevents from accidentally saving local commits into shared servers, causing 
+subsequent pushes from other clients to fail because they can't get that 
+commit from the git tree in order to get differences.
+
+### version
+
+Creates a new version folder, when name is not specified it generates a random 
+name mixing a color with a plant name.
+
+```text
+$ myt version [<name>]
+```
+
+### clean
+
+Cleans all already applied versions older than  *maxOldVersions*.
+
+```text
+$ myt clean
+```
+
+## Local server commands
+
+### dump
+
+Exports database structure and fixtures from remote into hidden files located
+in *dump* folder. If no remote is specified *production* is used.
+
+```text
+$ myt dump [<remote>]
+```
+
+### fixtures
+
+Exports local database fixtures into *dump/fixtures.sql* files. If no remote is
+specified *local* is used.
+
+```text
+$ myt fixtures [<remote>]
+```
+
+### run
+
+Builds and starts local database server container. It only rebuilds the image 
+when fixtures have been modified or when the day on which the image was built 
+is different to today.
+
+```text
+$ myt run [-c|--ci] [-r|--random]
+```
+
+### start
+
+Starts local database server container. It does the minium effort, if it 
+doesn't exists calls the run command, if it is started does nothing. Keep in 
+mind that when you do not rebuild the docker you may be using an outdated 
+version of it.
+
+```text
+$ myt start
+```
+
+## Why
+
+The main reason for starting this project it's because there are no fully free 
+and open source migration tools available that allow versioning database 
+routines with an standard CVS system as if they were normal application code.
+
+Also, the existing tools are too complex and require too much knowledge to 
+start a small project.
+
+## ToDo
+
+* Undo changes when there is an error applying a version using "undo" files.
+* Console logging via events.
+* Lock version table row when pushing.
+* Preserve all characteristics on pull: SQL mode, character set, algorithm...
+
+## Built With
+
+* [Git](https://git-scm.com/)
+* [nodejs](https://nodejs.org/)
+* [NodeGit](https://www.nodegit.org/)
+* [docker](https://www.docker.com/)

package/assets/db.ini

@@ -0,0 +1,5 @@
+[client]
+host = localhost
+port = 3306
+user = root
+password = root

package/assets/myvc.default.yml

@@ -0,0 +1,9 @@
+versionSchema: myt
+versionDigits: 5
+maxOldVersions: 30
+schemas:
+  - myt
+fixtures:
+  myt:
+    - version
+    - versionLog

package/assets/structure.sql

@@ -0,0 +1,24 @@
+
+CREATE TABLE `version` (
+    `code` VARCHAR(50) NOT NULL,
+    `number` CHAR(11) NULL DEFAULT NULL,
+    `gitCommit` VARCHAR(255) NULL DEFAULT NULL,
+    `updated` DATETIME NOT NULL,
+    `lastNumber` CHAR(11) NULL DEFAULT NULL
+) ENGINE=InnoDB;
+
+ALTER TABLE `version`
+    ADD PRIMARY KEY (`code`);
+
+CREATE TABLE `versionLog` (
+    `code` VARCHAR(50) NOT NULL,
+    `number` CHAR(11) NOT NULL,
+    `file` VARCHAR(255) NOT NULL,
+    `user` VARCHAR(255) NULL,
+    `updated` DATETIME NOT NULL,
+    `errorNumber` INT(10) UNSIGNED DEFAULT NULL,
+    `errorMessage` VARCHAR(255) DEFAULT NULL
+) ENGINE=InnoDB;
+
+ALTER TABLE `versionLog`
+    ADD PRIMARY KEY (`code`,`number`,`file`);

package/cli.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+const Myt = require('./myt');
+new Myt().run();

package/exporters/event.ejs

@@ -0,0 +1,21 @@
+DROP EVENT IF EXISTS <%- schema %>.<%- name %>;
+DELIMITER $$
+CREATE DEFINER=<%- definer %> EVENT <%- schema %>.<%- name %><%
+if (type == 'RECURRING') { %>
+	ON SCHEDULE EVERY <%- intervalValue %> <%- intervalField %><%
+	if (starts) { %>
+		STARTS <%- starts %><%
+	}
+	if (ends) { %>
+		ENDS <%- ends %><%
+	}
+} else { %>
+	ON SCHEDULE AT <%- executeAt %><%
+} %>
+	ON COMPLETION <%- onCompletion %>
+	<%- status %><%
+if (comment) { %>
+	COMMENT <%- comment %><%
+} %>
+DO <%- body %>$$
+DELIMITER ;

package/exporters/event.js

@@ -0,0 +1,25 @@
+
+module.exports = {
+    schemaCol: 'EVENT_SCHEMA',
+    nameCol: 'EVENT_NAME',
+    escapeCols: [
+        'starts',
+        'ends',
+        'executeAt',
+        'comment'
+    ],
+    formatter(params) {
+        let status;
+        switch(params.status){
+        case 'DISABLED':
+            status = 'DISABLE';
+            break;
+        case 'SLAVESIDE_DISABLED':
+            status = 'DISABLE ON SLAVE';
+            break;
+        default:
+            status = 'ENABLE'
+        }
+        params.status = status;
+    }
+};

package/exporters/event.sql

@@ -0,0 +1,19 @@
+
+SELECT 
+		`EVENT_SCHEMA` AS `schema`,
+		`EVENT_NAME` AS `name`,
+		`DEFINER` AS `definer`,
+		`EVENT_DEFINITION` AS `body`,
+		`EVENT_TYPE` AS `type`,
+		`EXECUTE_AT` AS `executeAt`,
+		`INTERVAL_VALUE` AS `intervalValue`,
+		`INTERVAL_FIELD` AS `intervalField`,
+		`STARTS` AS `starts`,
+		`ENDS` AS `ends`,
+		`STATUS` AS `status`,
+		`ON_COMPLETION` AS `onCompletion`,
+		`EVENT_COMMENT` AS `comment`,
+		`LAST_ALTERED` AS `modified`
+	FROM `information_schema`.`EVENTS`
+	WHERE ?
+	ORDER BY `name`

package/exporters/function.ejs

@@ -0,0 +1,20 @@
+DROP FUNCTION IF EXISTS <%- schema %>.<%- name %>;
+DELIMITER $$
+CREATE DEFINER=<%- definer %> FUNCTION <%- schema %>.<%- name %>(<%- paramList %>)
+	RETURNS <%- returns %><%
+if (isDeterministic == 'NO') { %>
+	NOT DETERMINISTIC<%
+} else { %>
+	DETERMINISTIC<%
+}
+if (dataAccess) { %>
+	<%- dataAccess %><%
+}
+if (securityType == 'INVOKER') { %>
+	SQL SECURITY  <%- securityType %><%
+}
+if (comment) { %>
+	COMMENT <%- comment %><%
+} %>
+<%- body %>$$
+DELIMITER ;

package/exporters/function.js

@@ -0,0 +1,23 @@
+
+module.exports = {
+    schemaCol: 'db',
+    nameCol: 'name',
+    escapeCols: [
+        'comment'
+    ],
+    formatter(params) {
+        let dataAccess;
+        switch(params.dataAccess) {
+        case 'NO_SQL':
+            dataAccess = 'NO SQL';
+            break;
+        case 'READS_SQL_DATA':
+            dataAccess = 'READS SQL DATA';
+            break;
+        case 'MODIFIES_SQL_DATA':
+            dataAccess = 'MODIFIES SQL DATA';
+            break;
+        }
+        params.dataAccess = dataAccess;
+    }
+};

package/exporters/function.sql

@@ -0,0 +1,16 @@
+
+SELECT
+		`db` AS `schema`,
+		`name`,
+		`definer`,
+		`param_list` AS `paramList`,
+		`body`,
+		`sql_data_access` AS `dataAccess`,
+		`security_type` AS `securityType`,
+		`comment`,
+		`modified`,
+		`is_deterministic` AS `isDeterministic`,
+		`returns`
+	FROM `mysql`.`proc`
+	WHERE ? AND `type` = 'FUNCTION'
+	ORDER BY `name`

package/exporters/procedure.ejs

@@ -0,0 +1,14 @@
+DROP PROCEDURE IF EXISTS <%- schema %>.<%- name %>;
+DELIMITER $$
+CREATE DEFINER=<%- definer %> PROCEDURE <%- schema %>.<%- name %>(<%- paramList %>)<%
+if (dataAccess) { %>
+	<%- dataAccess %><%
+}
+if (securityType == 'INVOKER') { %>
+	SQL SECURITY  <%- securityType %><%
+}
+if (comment) { %>
+	COMMENT <%- comment %><%
+} %>
+<%- body %>$$
+DELIMITER ;

package/exporters/procedure.js

@@ -0,0 +1,23 @@
+
+module.exports = {
+    schemaCol: 'db',
+    nameCol: 'name',
+    escapeCols: [
+        'comment'
+    ],
+    formatter(params) {
+        let dataAccess;
+        switch(params.dataAccess) {
+        case 'NO_SQL':
+            dataAccess = 'NO SQL';
+            break;
+        case 'READS_SQL_DATA':
+            dataAccess = 'READS SQL DATA';
+            break;
+        case 'MODIFIES_SQL_DATA':
+            dataAccess = 'MODIFIES SQL DATA';
+            break;
+        }
+        params.dataAccess = dataAccess;
+    }
+};

package/exporters/procedure.sql

@@ -0,0 +1,14 @@
+
+SELECT
+		`db` AS `schema`,
+		`name`,
+		`definer`,
+		`param_list` AS `paramList`,
+		`body`,
+		`sql_data_access` AS `dataAccess`,
+		`security_type` AS `securityType`,
+		`comment`,
+		`modified`
+	FROM `mysql`.`proc`
+	WHERE ? AND `type` = 'PROCEDURE'
+	ORDER BY `name`

package/exporters/trigger.ejs

@@ -0,0 +1,7 @@
+DROP TRIGGER IF EXISTS <%- schema %>.<%- name %>;
+DELIMITER $$
+CREATE DEFINER=<%- definer %> TRIGGER <%- schema %>.<%- name %>
+	<%- actionTiming %> <%- actionType %> ON `<%- table %>`
+	FOR EACH ROW
+<%- body %>$$
+DELIMITER ;

package/exporters/trigger.js

@@ -0,0 +1,5 @@
+
+module.exports = {
+    schemaCol: 'TRIGGER_SCHEMA',
+    nameCol: 'TRIGGER_NAME'
+};

package/exporters/trigger.sql

@@ -0,0 +1,13 @@
+
+SELECT
+		`TRIGGER_SCHEMA` AS `schema`,
+		`TRIGGER_NAME` AS `name`,
+		`DEFINER` AS `definer`,
+		`ACTION_TIMING` AS `actionTiming`,
+		`EVENT_MANIPULATION` AS `actionType`,
+		`EVENT_OBJECT_TABLE` AS `table`,
+		`ACTION_STATEMENT` AS `body`,
+		`CREATED` AS `modified`
+	FROM `information_schema`.`TRIGGERS`
+	WHERE ?
+	ORDER BY `name`

package/exporters/view.ejs

@@ -0,0 +1,7 @@
+CREATE OR REPLACE DEFINER=<%- definer %>
+	SQL SECURITY <%- securityType %>
+	VIEW <%- schema %>.<%- name %>
+AS <%- definition %><%
+if (checkOption != 'NONE') { %>
+WITH <%- checkOption %> CHECK OPTION<%
+} %>

package/exporters/view.js

@@ -0,0 +1,25 @@
+
+const sqlFormatter = require('@sqltools/formatter');
+
+module.exports = {
+    schemaCol: 'TABLE_SCHEMA',
+    nameCol: 'TABLE_NAME',
+    formatter(params) {
+        params.definition = sqlFormatter.format(params.definition, {
+            indent: '\t',
+            reservedWordCase: 'upper'
+        });
+
+        let algorithm;
+        switch (params.isUpdatable) {
+        case 'YES':
+            algorithm = 'MERGE';
+            break;
+        case 'NO':
+            algorithm = 'TEMPTABLE';
+            break;
+        default:
+            algorithm = 'UNDEFINED';
+        }
+    }
+};

package/exporters/view.sql

@@ -0,0 +1,12 @@
+
+SELECT
+		`TABLE_SCHEMA` AS `schema`,
+		`TABLE_NAME` AS `name`,
+		`VIEW_DEFINITION` AS `definition`,
+		`CHECK_OPTION` AS `checkOption`,
+		`IS_UPDATABLE` AS `isUpdatable`,
+		`DEFINER` AS `definer`,
+		`SECURITY_TYPE` AS `securityType`
+	FROM `information_schema`.`VIEWS`
+	WHERE ?
+	ORDER BY `name`

package/lib/command.js

@@ -0,0 +1,16 @@
+/**
+ * Base class for Myt commands.
+ */
+module.exports = class MytCommand {
+    get usage() {
+        return {};
+    }
+
+    get localOpts() {
+        return {};
+    }
+
+    async run(myt, opts) {
+        throw new Error('run command not defined');
+    }
+}