@verdnatura/myt 1.5.19 → 1.5.21

package/lib/server.js

@@ -1,71 +1,71 @@
-
-const mysql = require('mysql2/promise');
-
-module.exports = class Server {
-    constructor(ct, dbConfig) {
-        Object.assign(this, {
-            ct,
-            dbConfig
-        });
-    }
-
-    wait() {
-        return new Promise((resolve, reject) => {
-            const mysql = require('mysql2');
-
-            let interval = 100;
-            let elapsedTime = 0;
-            let maxInterval = 4 * 60 * 1000;
-
-            const dbConfig = this.dbConfig;
-            let myConf = {
-                user: dbConfig.user,
-                password: dbConfig.password,
-                host: dbConfig.host,
-                port: dbConfig.port
-            };
-
-            console.log('Waiting for MySQL init process...');
-
-            async function checker() {
-                elapsedTime += interval;
-                let status;
-
-                try {
-                    status =  await this.ct.inspect({
-                        format: '{{json .State.Status}}'
-                    });
-                } catch (err) {
-                    return reject(new Error(err.message));
-                }
-
-                if (status === 'exited')
-                    return reject(new Error('Docker exited, please see the docker logs for more info'));
-
-                const conn = mysql.createConnection(myConf);
-                conn.on('error', () => {});
-                conn.connect(err => {
-                    conn.destroy();
-                    if (!err) {
-                        console.log('MySQL process ready.');
-                        return resolve();
-                    }
-
-                    if (elapsedTime >= maxInterval)
-                        reject(new Error(`MySQL not initialized whithin ${elapsedTime / 1000} secs`));
-                    else
-                        setTimeout(bindedChecker, interval);
-                });
-            }
-            const bindedChecker = checker.bind(this);
-            bindedChecker();
-        });
-    }
-
-    async rm() {
-        try {
-            await this.ct.stop();
-            await this.ct.rm({volumes: true});
-        } catch (e) {}
-    }
-};
+
+const mysql = require('mysql2/promise');
+
+module.exports = class Server {
+    constructor(ct, dbConfig) {
+        Object.assign(this, {
+            ct,
+            dbConfig
+        });
+    }
+
+    wait() {
+        return new Promise((resolve, reject) => {
+            const mysql = require('mysql2');
+
+            let interval = 100;
+            let elapsedTime = 0;
+            let maxInterval = 4 * 60 * 1000;
+
+            const dbConfig = this.dbConfig;
+            let myConf = {
+                user: dbConfig.user,
+                password: dbConfig.password,
+                host: dbConfig.host,
+                port: dbConfig.port
+            };
+
+            console.log('Waiting for MySQL init process...');
+
+            async function checker() {
+                elapsedTime += interval;
+                let status;
+
+                try {
+                    status =  await this.ct.inspect({
+                        format: '{{json .State.Status}}'
+                    });
+                } catch (err) {
+                    return reject(new Error(err.message));
+                }
+
+                if (status === 'exited')
+                    return reject(new Error('Docker exited, please see the docker logs for more info'));
+
+                const conn = mysql.createConnection(myConf);
+                conn.on('error', () => {});
+                conn.connect(err => {
+                    conn.destroy();
+                    if (!err) {
+                        console.log('MySQL process ready.');
+                        return resolve();
+                    }
+
+                    if (elapsedTime >= maxInterval)
+                        reject(new Error(`MySQL not initialized whithin ${elapsedTime / 1000} secs`));
+                    else
+                        setTimeout(bindedChecker, interval);
+                });
+            }
+            const bindedChecker = checker.bind(this);
+            bindedChecker();
+        });
+    }
+
+    async rm() {
+        try {
+            await this.ct.stop();
+            await this.ct.rm({volumes: true});
+        } catch (e) {}
+    }
+};

package/lib/util.js

@@ -1,7 +1,7 @@
-function camelToSnake(str) {
-    return str.replace(/[A-Z]/g, match => `-${match.toLowerCase()}`);
-}
-
-module.exports = {
-    camelToSnake
-};
+function camelToSnake(str) {
+    return str.replace(/[A-Z]/g, match => `-${match.toLowerCase()}`);
+}
+
+module.exports = {
+    camelToSnake
+};

package/myt-clean.js

@@ -1,58 +1,58 @@
-const Myt = require('./myt');
-const Command = require('./lib/command');
-const fs = require('fs-extra');
-const path = require('path');
-
-/**
- * Cleans old applied versions.
- */
-class Clean extends Command {
-    static usage = {
-        description: 'Cleans old applied versions'
-    };
-
-    static opts = {
-        default: {
-            remote: 'production'
-        }
-    };
-
-    async run(myt, opts) {
-        await myt.dbConnect();
-        const version = await myt.fetchDbVersion() || {};
-        const number = version.number;
-
-        const oldVersions = [];
-        const versionDirs = await fs.readdir(opts.versionsDir);
-        for (const versionDir of versionDirs) {
-            const dirVersion = myt.parseVersionDir(versionDir);
-            if (!dirVersion) continue;
-
-            if (parseInt(dirVersion.number) < parseInt(number))
-                oldVersions.push(versionDir);
-        }
-
-        if (opts.maxOldVersions
-        && oldVersions.length > opts.maxOldVersions) {
-            oldVersions.splice(-opts.maxOldVersions);
-
-            const archiveDir = path.join(opts.versionsDir, '.archive');
-            if (!await fs.pathExists(archiveDir))
-                await fs.mkdir(archiveDir);
-
-            for (const oldVersion of oldVersions)
-                await fs.move(
-                    path.join(opts.versionsDir, oldVersion),
-                    path.join(archiveDir, oldVersion)
-                );
-
-            console.log(`Old versions deleted: ${oldVersions.length}`);
-        } else
-            console.log(`No versions to delete.`);
-    }
-}
-
-module.exports = Clean;
-
-if (require.main === module)
-    new Myt().run(Clean);
+const Myt = require('./myt');
+const Command = require('./lib/command');
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Cleans old applied versions.
+ */
+class Clean extends Command {
+    static usage = {
+        description: 'Cleans old applied versions'
+    };
+
+    static opts = {
+        default: {
+            remote: 'production'
+        }
+    };
+
+    async run(myt, opts) {
+        await myt.dbConnect();
+        const version = await myt.fetchDbVersion() || {};
+        const number = version.number;
+
+        const oldVersions = [];
+        const versionDirs = await fs.readdir(opts.versionsDir);
+        for (const versionDir of versionDirs) {
+            const dirVersion = myt.parseVersionDir(versionDir);
+            if (!dirVersion) continue;
+
+            if (parseInt(dirVersion.number) < parseInt(number))
+                oldVersions.push(versionDir);
+        }
+
+        if (opts.maxOldVersions
+        && oldVersions.length > opts.maxOldVersions) {
+            oldVersions.splice(-opts.maxOldVersions);
+
+            const archiveDir = path.join(opts.versionsDir, '.archive');
+            if (!await fs.pathExists(archiveDir))
+                await fs.mkdir(archiveDir);
+
+            for (const oldVersion of oldVersions)
+                await fs.move(
+                    path.join(opts.versionsDir, oldVersion),
+                    path.join(archiveDir, oldVersion)
+                );
+
+            console.log(`Old versions deleted: ${oldVersions.length}`);
+        } else
+            console.log(`No versions to delete.`);
+    }
+}
+
+module.exports = Clean;
+
+if (require.main === module)
+    new Myt().run(Clean);

package/myt-create.js

@@ -1,74 +1,74 @@
-const Myt = require('./myt');
-const Command = require('./lib/command');
-const Exporter = require('./lib/exporter');
-const fs = require('fs-extra');
-
-class Create extends Command {
-    static usage = {
-        description: 'Creates a new DB object',
-        params: {
-            type: 'The object type',
-            name: 'The object name, including schema'
-        },
-        operand: 'name'
-    };
-
-    static opts = {
-        alias: {
-            type: 't',
-            name: 'n'
-        },
-        string: [
-            'type',
-            'name'
-        ],
-        default: {
-            type: 'procedure'
-        }
-    };
-
-    async run(myt, opts) {
-        const match = opts.name.match(/^(\w+)\.(\w+)$/);
-        if (!match)
-            throw new Error('Invalid object name, should contain schema and routine name');
-
-        const schema = match[1];
-        const name = match[2];
-
-        const params = {
-            schema,
-            name,
-            definer: 'root@localhost'
-        };
-
-        switch (opts.type) {
-            case 'event':
-            case 'function':
-            case 'procedure':
-            case 'trigger':
-                params.body = "BEGIN\n-- Your code goes here\nEND";
-                break;
-            case 'view':
-                params.definition = "SELECT TRUE"
-                break;
-        }
-
-        const exporter = new Exporter(opts.type, opts.replace);
-        await exporter.init();
-        const sql = exporter.format(params);
-
-        const routineDir = `${opts.routinesDir}/${schema}/${opts.type}s`;
-        if (!await fs.pathExists(routineDir))
-            await fs.mkdir(routineDir);
-
-        const routineFile = `${routineDir}/${name}.sql`;
-        await fs.writeFile(routineFile, sql);
-
-        console.log('Routine created.');
-    }
-}
-
-module.exports = Create;
-
-if (require.main === module)
-    new Myt().run(Create);
+const Myt = require('./myt');
+const Command = require('./lib/command');
+const Exporter = require('./lib/exporter');
+const fs = require('fs-extra');
+
+class Create extends Command {
+    static usage = {
+        description: 'Creates a new DB object',
+        params: {
+            type: 'The object type',
+            name: 'The object name, including schema'
+        },
+        operand: 'name'
+    };
+
+    static opts = {
+        alias: {
+            type: 't',
+            name: 'n'
+        },
+        string: [
+            'type',
+            'name'
+        ],
+        default: {
+            type: 'procedure'
+        }
+    };
+
+    async run(myt, opts) {
+        const match = opts.name.match(/^(\w+)\.(\w+)$/);
+        if (!match)
+            throw new Error('Invalid object name, should contain schema and routine name');
+
+        const schema = match[1];
+        const name = match[2];
+
+        const params = {
+            schema,
+            name,
+            definer: 'root@localhost'
+        };
+
+        switch (opts.type) {
+            case 'event':
+            case 'function':
+            case 'procedure':
+            case 'trigger':
+                params.body = "BEGIN\n-- Your code goes here\nEND";
+                break;
+            case 'view':
+                params.definition = "SELECT TRUE"
+                break;
+        }
+
+        const exporter = new Exporter(opts.type, opts.replace);
+        await exporter.init();
+        const sql = exporter.format(params);
+
+        const routineDir = `${opts.routinesDir}/${schema}/${opts.type}s`;
+        if (!await fs.pathExists(routineDir))
+            await fs.mkdir(routineDir);
+
+        const routineFile = `${routineDir}/${name}.sql`;
+        await fs.writeFile(routineFile, sql);
+
+        console.log('Routine created.');
+    }
+}
+
+module.exports = Create;
+
+if (require.main === module)
+    new Myt().run(Create);

package/myt-dump.js

@@ -1,75 +1,134 @@
-const Myt = require('./myt');
-const Command = require('./lib/command');
-const fs = require('fs-extra');
-const Dumper = require('./lib/dumper');
-
-class Dump extends Command {
-    static usage = {
-        description: 'Dumps structure and fixtures from remote',
-        params: {
-            lock: 'Whether to lock tables on dump'
-        },
-        operand: 'remote'
-    };
-
-    static opts = {
-        default: {
-            remote: 'production'
-        },
-        alias: {
-            lock: 'l'
-        },
-        boolean: [
-            'lock'
-        ]
-    };
-
-    async run(myt, opts) {
-        const dumper = new Dumper(opts);
-        await dumper.init('.dump.sql');
-        const baseArgs = [
-            `--lock-tables=${opts.lock ? 'true' : 'false'}`
-        ];
-
-        console.log('Dumping structure.');
-        let dumpArgs = [
-            '--default-character-set=utf8',
-            '--no-data',
-            '--comments',
-            '--routines',
-            '--events',
-            '--skip-triggers',
-            '--databases'
-        ].concat(baseArgs);
-
-        dumpArgs = dumpArgs.concat(opts.schemas);
-        await dumper.runDump('docker-dump.sh', dumpArgs);
-
-        console.log('Dumping fixtures.');
-        await dumper.dumpFixtures(opts.fixtures, false, baseArgs);
-
-        console.log('Dumping privileges.');
-        const privs = opts.privileges;
-        if (privs && Array.isArray(privs.tables)) {
-            let args = [
-                '--no-create-info',
-                '--skip-triggers',
-                '--insert-ignore',
-                '--complete-insert'
-            ].concat(baseArgs);
-            if (privs.where) args.push('--where', privs.where);
-            args = args.concat(['mysql'], privs.tables);
-
-            await dumper.use('mysql');
-            await dumper.runDump('mysqldump', args);
-        }
-
-        await dumper.end();
-    }
-}
-
-module.exports = Dump;
-
-if (require.main === module)
-    new Myt().run(Dump);
-
+const Myt = require('./myt');
+const Command = require('./lib/command');
+const Dumper = require('./lib/dumper');
+const fs = require('fs-extra');
+const path = require('path');
+
+class Dump extends Command {
+    static usage = {
+        description: 'Dumps structure and fixtures from remote',
+        params: {
+            lock: 'Whether to lock tables on dump',
+            triggers: 'Wether to include triggers into dump'
+        },
+        operand: 'remote'
+    };
+
+    static opts = {
+        default: {
+            remote: 'production'
+        },
+        alias: {
+            lock: 'l',
+            triggers: 't'
+        },
+        boolean: [
+            'lock',
+            'triggers'
+        ]
+    };
+
+    static messages = {
+        dumpStructure: 'Dumping structure.',
+        dumpData: 'Dumping data.',
+        dumpPrivileges: 'Dumping privileges.',
+        dumpTriggers: 'Dumping triggers.'
+    };
+
+    async run(myt, opts) {
+        let dumper;
+        const dumpDataDir = path.join(opts.dumpDir, '.dump');
+        const baseArgs = [
+            `--lock-tables=${opts.lock ? 'true' : 'false'}`
+        ];
+
+        await fs.remove(dumpDataDir);
+
+        // Structure
+
+        this.emit('dumpStructure');
+
+        dumper = new Dumper(opts);
+        await dumper.init(dumpDataDir, 'structure');
+        let dumpArgs = [
+            '--default-character-set=utf8',
+            '--no-data',
+            '--comments',
+            '--routines',
+            '--events',
+            '--skip-triggers'
+        ].concat(baseArgs);
+
+        dumpArgs.push('--databases');
+        dumpArgs = dumpArgs.concat(opts.schemas);
+        await dumper.runDump('docker-dump.sh', dumpArgs);
+        await dumper.end();
+
+        // Data
+
+        this.emit('dumpData');
+
+        dumper = new Dumper(opts);
+        await dumper.init(dumpDataDir, 'data');
+        await dumper.dumpFixtures(opts.fixtures, false, baseArgs);
+        await dumper.end();
+
+        // Privileges
+
+        const privs = opts.privileges;
+        if (privs) {
+            this.emit('dumpPrivileges');
+
+            dumper = new Dumper(opts);
+            await dumper.init(dumpDataDir, 'privileges');
+
+            const {tables, userTable, where} = privs;
+
+            if (tables)
+                await dumper.dumpPrivileges(tables, baseArgs, where);
+
+            if (userTable) {
+                let userWhere = '';
+                for (const cond of [where, privs.userWhere]) {
+                    if (!cond) continue;
+                    if (userWhere) userWhere += ' AND ';
+                    userWhere += cond;
+                }
+                await dumper.dumpPrivileges([userTable], baseArgs, userWhere);
+            }
+
+            await dumper.end();
+        }
+
+        await dumper.end();
+
+        // Triggers
+
+        if (opts.triggers) {
+            this.emit('dumpTriggers');
+
+            const dumper = new Dumper(opts);
+            await dumper.init(dumpDataDir, 'triggers');
+
+            let dumpArgs = [
+                '--default-character-set=utf8',
+                '--no-create-info',
+                '--no-data',
+                '--no-create-db',
+                '--skip-opt',
+                '--comments'
+            ].concat(baseArgs);
+
+            dumpArgs.push('--databases');
+            dumpArgs = dumpArgs.concat(opts.schemas);
+            await dumper.runDump('mysqldump', dumpArgs);
+            await dumper.end();
+        }
+    }
+}
+
+module.exports = Dump;
+
+if (require.main === module)
+    new Myt().run(Dump);
+