@verdnatura/myt 1.5.6 → 1.5.8

package/myt.js

@@ -10,52 +10,46 @@ const path = require('path');
 const mysql = require('mysql2/promise');
 const nodegit = require('nodegit');
 const camelToSnake = require('./lib/util').camelToSnake;
-const docker = require('./lib/docker');
-const Command = require('./lib/command');
 
 class Myt {
-    get usage() {
-        return {
-            description: 'Utility for database versioning',
-            params: {
-                remote: 'Name of remote to use',
-                workspace: 'The base directory of the project',
-                socket: 'Wether to connect to database via socket',
-                debug: 'Wether to enable debug mode',
-                version: 'Display the version number and exit',
-                help: 'Display this help message'
-            }
-        };
-    }
-
-    get localOpts() {
-        return {
-            alias: {
-                remote: 'r',
-                workspace: 'w',
-                socket: 'k',
-                debug: 'd',
-                version: 'v',
-                help: 'h'
-            },
-            boolean: [
-                'debug',
-                'version',
-                'help'
-            ],
-            default: {
-                workspace: process.cwd()
-            }
-        };
-    }
-
-    async run(CommandClass) {
+    static usage = {
+        description: 'Utility for database versioning',
+        params: {
+            remote: 'Name of remote to use',
+            workspace: 'The base directory of the project',
+            socket: 'Wether to connect to database via socket',
+            debug: 'Wether to enable debug mode',
+            version: 'Display the version number and exit',
+            help: 'Display this help message'
+        }
+    };
+
+    static opts = {
+        alias: {
+            remote: 'r',
+            workspace: 'w',
+            socket: 'k',
+            debug: 'd',
+            version: 'v',
+            help: 'h'
+        },
+        boolean: [
+            'debug',
+            'version',
+            'help'
+        ]
+    };
+
+    async run(Command) {
         console.log(
             'Myt'.green,
             `v${packageJson.version}`.magenta
         );
 
-        const baseOpts = this.localOpts;
+        let baseOpts = this.constructor.opts;
+        baseOpts.default = Object.assign(baseOpts.default || {}, {
+            workspace: process.cwd()
+        });
         const opts = this.getopts(baseOpts);
 
         if (opts.debug) {
@@ -68,7 +62,7 @@ class Myt {
 
         try {
             const commandName = opts._[0];
-            if (!CommandClass && commandName) {
+            if (!Command && commandName) {
                 if (!/^[a-z]+$/.test(commandName))
                     throw new Error (`Invalid command name '${commandName}'`);
 
@@ -76,20 +70,20 @@ class Myt {
 
                 if (!await fs.pathExists(commandFile))
                     throw new Error (`Unknown command '${commandName}'`);
-                CommandClass = require(commandFile);
+                Command = require(commandFile);
             }
 
-            if (!CommandClass) {
-                this.showHelp(baseOpts, this.usage);
+            if (!Command) {
+                this.showHelp(baseOpts, this.constructor.usage);
                 process.exit(0);
             }
 
             const allOpts = Object.assign({}, baseOpts);
 
-            if (CommandClass.localOpts)
-            for (const key in CommandClass.localOpts) {
+            if (Command.opts)
+            for (const key in Command.opts) {
                 const baseValue = baseOpts[key];
-                const cmdValue = CommandClass.localOpts[key];
+                const cmdValue = Command.opts[key];
                 if (Array.isArray(baseValue))
                     allOpts[key] = baseValue.concat(cmdValue);
                 else if (typeof baseValue == 'object')
@@ -103,7 +97,7 @@ class Myt {
                 console.log('Command options:'.magenta, commandOpts);
             Object.assign(opts, commandOpts);
 
-            const operandToOpt = CommandClass.usage.operand;
+            const operandToOpt = Command.usage.operand;
             if (opts._.length >= 2 && operandToOpt)
                 opts[operandToOpt] = opts._[1];
 
@@ -111,7 +105,7 @@ class Myt {
                 console.log('Final options:'.magenta, opts);
 
             if (opts.help) {
-                this.showHelp(CommandClass.localOpts, CommandClass.usage, commandName);
+                this.showHelp(Command.opts, Command.usage, commandName);
                 process.exit(0);
             }
 
@@ -150,7 +144,7 @@ class Myt {
             parameter('Remote:', opts.remote || 'local');
 
             await this.load(opts);
-            await this.runCommand(CommandClass, opts);
+            await this.runCommand(Command, opts);
             await this.unload();
         } catch (err) {
             if (err.name == 'Error' && !opts.debug) {
@@ -169,9 +163,8 @@ class Myt {
         process.exit();
     }
 
-    async runCommand(CommandClass, opts) {
-        const command = new CommandClass();
-        command.opts = opts;
+    async runCommand(Command, opts) {
+        const command = new Command(this, opts);
         return await command.run(this, opts);
     }
 
@@ -315,70 +308,6 @@ class Myt {
         };
     }
 
-    async changedRoutines(commitSha) {
-        const repo = await this.openRepo();
-        const changes = [];
-        const changesMap = new Map();
-
-        async function pushChanges(diff) {
-            if (!diff) return;
-            const patches = await diff.patches();
-
-            for (const patch of patches) {
-                const path = patch.newFile().path();
-                const match = path.match(/^routines\/(.+)\.sql$/);
-                if (!match) continue;
-
-                let change = changesMap.get(match[1]);
-                if (!change) {
-                    change = {path: match[1]};
-                    changes.push(change);
-                    changesMap.set(match[1], change);
-                }
-                change.mark = patch.isDeleted() ? '-' : '+';
-            }
-        }
-
-        const head = await repo.getHeadCommit();
-
-        if (head && commitSha) {
-            let commit;
-            let notFound;
-
-            try {
-                commit = await repo.getCommit(commitSha);
-                notFound = false;
-            } catch (err) {
-                if (err.errorFunction == 'Commit.lookup')
-                    notFound = true;
-                else
-                    throw err;
-            }
-
-            if (notFound) {
-                console.warn(`Database commit not found, trying git fetch`.yellow);
-                await repo.fetchAll();
-                commit = await repo.getCommit(commitSha);
-            }
-
-            const commitTree = await commit.getTree();
-
-            const headTree = await head.getTree();
-            const diff = await headTree.diff(commitTree);
-            await pushChanges(diff);
-        }
-
-        await pushChanges(await this.getUnstaged(repo));
-        await pushChanges(await this.getStaged(repo));
-
-        return changes.sort((a, b) => {
-            if (b.mark != a.mark)
-                return b.mark == '-' ? 1 : -1;
-            return a.path.localeCompare(b.path);
-            
-        });
-    }
-
     async openRepo() {
         const {opts} = this;
 
@@ -388,94 +317,6 @@ class Myt {
         return await nodegit.Repository.open(opts.workspace);
     }
 
-    async getStaged(repo) {
-        const head = await repo.getHeadCommit();
-
-        try {
-            const emptyTree = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
-            const headTree = await (head
-                ? head.getTree()
-                : nodegit.Tree.lookup(repo, emptyTree)
-            );
-            return await nodegit.Diff.treeToIndex(repo, headTree, null);
-        } catch (err) {
-            console.warn('Cannot fetch staged changes:', err.message);
-        }
-    }
-
-    async getUnstaged(repo) {
-        return await nodegit.Diff.indexToWorkdir(repo, null, {
-            flags: nodegit.Diff.OPTION.SHOW_UNTRACKED_CONTENT
-                | nodegit.Diff.OPTION.RECURSE_UNTRACKED_DIRS
-        });
-    }
-
-    async initDump(dumpFile) {
-        const dumpDir = this.opts.dumpDir;
-        if (!await fs.pathExists(dumpDir))
-            await fs.mkdir(dumpDir);
-
-        const dumpPath = path.join(dumpDir, dumpFile);
-
-        // FIXME: If it's called after docker.build() statement it creates an 
-        // "invalid" WriteStream
-        const dumpStream = await fs.createWriteStream(dumpPath);
-
-        await docker.build(__dirname, {
-            tag: 'myt/client',
-            file: path.join(__dirname, 'server', 'Dockerfile.client')
-        }, this.opts.debug);
-
-        return dumpStream;
-    }
-
-    async dumpFixtures(dumpStream, tables, replace) {
-        const fixturesArgs = [
-            '--no-create-info',
-            '--skip-triggers',
-            '--skip-extended-insert',
-            '--skip-disable-keys',
-            '--skip-add-locks',
-            '--skip-set-charset',
-            '--skip-comments',
-            '--skip-tz-utc'
-        ];
-
-        if (replace)
-            fixturesArgs.push('--replace');
-
-        for (const schema in tables) {
-            const escapedSchema = '`'+ schema.replace('`', '``') +'`';
-            await dumpStream.write(
-                `USE ${escapedSchema};\n`,
-                'utf8'
-            );
-
-            const args = fixturesArgs.concat([schema], tables[schema]);
-            await this.runDump('mysqldump', args, dumpStream);
-        }
-    }
-
-    async runDump(command, args, dumpStream) {
-        const iniPath = path.join(this.opts.subdir || '', 'remotes', this.opts.iniFile);
-        const myArgs = [
-            `--defaults-file=${iniPath}`
-        ];
-        const execOptions = {
-            stdio: [
-                process.stdin,
-                dumpStream,
-                process.stderr
-            ] 
-        };
-        const commandArgs = [command].concat(myArgs, args);
-        await docker.run('myt/client', commandArgs, {
-            addHost: 'host.docker.internal:host-gateway',
-            volume: `${this.opts.mytDir}:/workspace`,
-            rm: true
-        }, execOptions);
-    }
-
     showHelp(opts, usage, command) {
         const prefix = `${'Usage:'.gray} [npx] myt`;
 
@@ -505,139 +346,6 @@ class Myt {
             }
         }
     }
-
-    /**
-     * Executes an SQL script.
-     *
-     * @param {Connection} conn MySQL connection object
-     * @returns {Array<Result>} The resultset
-     */
-    async queryFromFile(conn, file) {
-        const sql = await fs.readFile(file, 'utf8');
-        return await this.multiQuery(conn, sql);
-    }
-
-    /**
-     * Executes a multi-query string.
-     *
-     * @param {Connection} conn MySQL connection object
-     * @param {String} sql SQL multi-query string
-     * @returns {Array<Result>} The resultset
-     */
-    async multiQuery(conn, sql) {
-        let results = [];
-        const stmts = this.querySplit(sql);
-
-        for (const stmt of stmts)
-            results = results.concat(await conn.query(stmt));
-
-        return results;
-    }
-
-    /**
-     * Splits an SQL muti-query into a single-query array, it does an small 
-     * parse to correctly handle the DELIMITER statement.
-     *
-     * @param {Array<String>} stmts The splitted SQL statements
-     */
-    querySplit(sql) {
-        const stmts = [];
-        let i,
-            char,
-            token,
-            escaped,
-            stmtStart;
-
-        let delimiter = ';';
-        const delimiterRe = /\s*delimiter\s+(\S+)[^\S\r\n]*(?:\r?\n|\r|$)/yi;
-
-        function begins(str) {
-            let j;
-            for (j = 0; j < str.length; j++)
-                if (sql[i + j] != str[j])
-                    return false;
-            i += j;
-            return true;
-        }
-
-        for (i = 0; i < sql.length;) {
-            stmtStart = i;
-
-            delimiterRe.lastIndex = i;
-            const match = sql.match(delimiterRe);
-            if (match) {
-                delimiter = match[1];
-                i += match[0].length;
-                continue;
-            }
-
-            let delimiterFound = false;
-            while (i < sql.length) {
-                char = sql[i];
-
-                if (token) {
-                    if (!escaped && begins(token.end))
-                        token = null;
-                    else {
-                        escaped = !escaped && token.escape(char);
-                        i++;
-                    }
-                } else {
-                    delimiterFound = begins(delimiter);
-                    if (delimiterFound) break;
-
-                    const tok = tokenIndex.get(char);
-                    if (tok && begins(tok.start))
-                        token = tok;
-                    else
-                        i++;
-                }
-            }
-
-            let len = i - stmtStart;
-            if (delimiterFound) len -= delimiter.length;
-            const stmt = sql.substr(stmtStart, len);
-
-            if (!/^\s*$/.test(stmt))
-                stmts.push(stmt);
-        }
-
-        return stmts;
-    }
-}
-
-const tokens = {
-    string: {
-        start: '\'',
-        end: '\'',
-        escape: char => char == '\'' || char == '\\'
-    },
-    quotedString: {
-        start: '"',
-        end: '"',
-        escape: char => char == '"' || char == '\\'
-    },
-    id: {
-        start: '`',
-        end: '`',
-        escape: char => char == '`'
-    },
-    multiComment: {
-        start: '/*',
-        end: '*/',
-        escape: () => false
-    },
-    singleComment: {
-        start: '-- ',
-        end: '\n',
-        escape: () => false
-    }
-};
-
-const tokenIndex = new Map();
-for (const tokenId in tokens) {
-    const token = tokens[tokenId];
-    tokenIndex.set(token.start[0], token);
 }
 
 module.exports = Myt;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@verdnatura/myt",
-  "version": "1.5.6",
+  "version": "1.5.8",
   "author": "Verdnatura Levante SL",
   "description": "MySQL version control",
   "license": "GPL-3.0",
@@ -12,7 +12,7 @@
     "url": "https://github.com/verdnatura/myt.git"
   },
   "dependencies": {
-    "@sqltools/formatter": "^1.2.3",
+    "@sqltools/formatter": "^1.2.5",
     "colors": "^1.4.0",
     "ejs": "^3.1.6",
     "fs-extra": "^8.1.0",

package/server/docker-dump.sh

@@ -1,4 +1,4 @@
 #!/bin/bash
 
 # FIXME: It can corrupt data
-mysqldump $@ | sed 's/ AUTO_INCREMENT=[0-9]* //g'
+mysqldump $@ | sed 's/ AUTO_INCREMENT=[0-9]*//g'

package/template/package.json

@@ -8,6 +8,6 @@
         "type": "git"
     },
     "dependencies": {
-        "@verdnatura/myt": "^1.5.6"
+        "@verdnatura/myt": "^1.5.8"
     }
 }

package/template/remotes/docker.ini

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