@verdnatura/myt 1.5.1

package/lib/docker.js

@@ -0,0 +1,133 @@
+const spawn = require('child_process').spawn;
+const execFile = require('child_process').execFile;
+const camelToSnake = require('./util').camelToSnake;
+
+const docker = {
+    async run(image, commandArgs, options, execOptions) {
+        const args = commandArgs
+            ? [image].concat(commandArgs)
+            : image;
+        const execMode = options.detach ? 'exec' : 'spawn';
+        
+        const child = await this.command('run',
+            args,
+            options,
+            execMode,
+            execOptions
+        );
+        return options.detach
+            ? new Container(child.stdout.trim())
+            : child;
+    },
+
+    async build(url, options, execOptions) {
+        return await this.command('build',
+            url,
+            options,
+            'spawn',
+            execOptions
+        );
+    },
+
+    async start(id, options) {
+        const ct = new Container(id);
+        await ct.start(options);
+        return ct;
+    },
+
+    async stop(id, options) {
+        const ct = new Container(id);
+        return await ct.stop(options);
+    },
+
+    async rm(id, options) {
+        const ct = new Container(id);
+        return await ct.rm(options);
+    },
+
+    async inspect(id, options) {
+        const ct = new Container(id);
+        return await ct.inspect(options);
+    },
+
+    async command(command, args, options, execMode, execOptions) {
+        const execArgs = [command];
+
+        if (options)
+            for (const option in options) {
+                execArgs.push(`--${camelToSnake(option)}`);
+                if (typeof options[option] !== 'boolean')
+                    execArgs.push(options[option]);
+            }
+
+        if (Array.isArray(args))
+            Array.prototype.push.apply(execArgs, args);
+        else if (args)
+            execArgs.push(args);
+
+        return await new Promise((resolve, reject) => {
+            if (execMode == 'spawn') {
+                if (execOptions === true)
+                    execOptions = {
+                        stdio: [
+                            process.stdin,
+                            process.stdout,
+                            process.stderr
+                        ] 
+                    };
+
+                const child = spawn('docker', execArgs, execOptions || undefined);
+                child.on('exit', code => {
+                    if (code !== 0) {
+                        const quotedArgs = execArgs
+                            .map(x => /\s/g.test(x) ? `"${x}"` : x)
+                            .join(' ');
+                        reject(new Error(`Docker exit code ${code}: 'docker ${quotedArgs}'`));
+                    } else
+                        resolve(code);
+                });
+            } else {
+                execFile('docker', execArgs, (err, stdout, stderr) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve({stdout, stderr});
+                });
+            }
+        });
+    }
+};
+
+class Container {
+    constructor(id) {
+        if (!id)
+            throw new Error('Container id argument is required');
+        this.id = id;
+    }
+
+    async start(options) {
+        await docker.command('start', this.id, options);
+    }
+
+    async stop(options) {
+        await docker.command('stop', this.id, options);
+    }
+
+    async rm(options) {
+        await docker.command('rm', this.id, options);
+    }
+
+    async inspect(options) {
+        const child = await docker.command('inspect', this.id, options);
+        return JSON.parse(child.stdout);
+    }
+
+    async exec(options, command, commandArgs, execMode, execOptions) {
+        let args = [this.id, command];
+        if (commandArgs) args = args.concat(commandArgs);
+        await docker.command('exec', args, options, execMode, execOptions);
+    }
+}
+
+module.exports = docker;
+module.exports.Container = Container;

package/lib/exporter-engine.js

@@ -0,0 +1,112 @@
+
+const shajs = require('sha.js');
+const fs = require('fs-extra');
+const Exporter = require('./exporter');
+
+module.exports = class ExporterEngine {
+    constructor(conn, mytDir) {
+        this.conn = conn;
+        this.pullFile = `${mytDir}/.pullinfo.json`;
+        this.exporters = [];
+        this.exporterMap = {};
+    }
+
+    async init () {
+        if (await fs.pathExists(this.pullFile)) {
+            this.pullInfo = JSON.parse(await fs.readFile(this.pullFile, 'utf8'));
+            const lastPull = this.pullInfo.lastPull;
+            if (lastPull)
+                this.pullInfo.lastPull = new Date(lastPull);
+        } else
+            this.pullInfo = {
+                lastPull: null,
+                shaSums: {}
+            };
+
+        this.shaSums = this.pullInfo.shaSums;
+        this.lastPull = this.pullInfo.lastPull;
+        this.infoChanged = false;
+
+        const types = [
+            'function',
+            'procedure',
+            'view',
+            'trigger',
+            'event'
+        ];
+
+        for (const type of types) {
+            const exporter = new Exporter(this, type, this.conn);
+            await exporter.init();
+
+            this.exporters.push(exporter);
+            this.exporterMap[type] = exporter;
+        }
+    }
+
+    async fetchRoutine(type, schema, name) {
+        const exporter = this.exporterMap[type];
+        const [row] = await exporter.query(schema, name);
+        return row && exporter.format(row);
+    }
+
+    async fetchShaSum(type, schema, name) {
+        const sql = await this.fetchRoutine(type, schema, name);
+        this.setShaSum(type, schema, name, this.shaSum(sql));
+    }
+
+    shaSum(sql) {
+        if (!sql) return null;
+        return shajs('sha256')
+            .update(JSON.stringify(sql))
+            .digest('hex');
+    }
+
+    getShaSum(type, schema, name) {
+        try {
+            return this.shaSums[schema][type][name];
+        } catch (e) {};
+
+        return null;
+    }
+
+    setShaSum(type, schema, name, shaSum) {
+        if (!shaSum) {
+            this.deleteShaSum(type, schema, name);
+            return;
+        }
+
+        const shaSums = this.shaSums;
+        if (!shaSums[schema])
+            shaSums[schema] = {};
+        if (!shaSums[schema][type])
+            shaSums[schema][type] = {};
+        shaSums[schema][type][name] = shaSum;
+        this.infoChanged = true;
+    }
+
+    deleteShaSum(type, schema, name) {
+        try {
+            delete this.shaSums[schema][type][name];
+            this.infoChanged = true;
+        } catch (e) {};
+    }
+
+    deleteSchemaSums(schema) {
+        delete this.shaSums[schema];
+        this.infoChanged = true;
+    }
+
+    async refreshPullDate() {
+        const [[row]] = await this.conn.query(`SELECT NOW() now`);
+        this.pullInfo.lastPull = row.now;
+        this.infoChanged = true;
+    }
+
+    async saveInfo() {
+        if (!this.infoChanged) return;
+        await fs.writeFile(this.pullFile,
+            JSON.stringify(this.pullInfo, null, '  '));
+        this.infoChanged = false;
+    }
+}

package/lib/exporter.js

@@ -0,0 +1,115 @@
+
+const ejs = require('ejs');
+const fs = require('fs-extra');
+
+module.exports = class Exporter {
+    constructor(engine, objectType, conn) {
+        this.engine = engine;
+        this.objectType = objectType;
+        this.dstDir = `${objectType}s`;
+        this.conn = conn;
+    }
+
+    async init() {
+        const templateDir = `${__dirname}/../exporters/${this.objectType}`;
+        this.sql = await fs.readFile(`${templateDir}.sql`, 'utf8');
+
+        const templateFile = await fs.readFile(`${templateDir}.ejs`, 'utf8');
+        this.template = ejs.compile(templateFile);
+        this.attrs = require(`${templateDir}.js`);
+    }
+
+    async export(exportDir, schema, update, saveSum) {
+        const res = await this.query(schema);
+        if (!res.length) return; 
+
+        const routineDir = `${exportDir}/${schema}/${this.dstDir}`;
+        if (!await fs.pathExists(routineDir))
+            await fs.mkdir(routineDir);
+
+        const routineSet = new Set();
+        for (const params of res)
+            routineSet.add(params.name);
+
+        const routines = await fs.readdir(routineDir);
+        for (const routineFile of routines) {
+            const match = routineFile.match(/^(.*)\.sql$/);
+            if (!match) continue;
+            const routine = match[1];
+            if (!routineSet.has(routine))
+                await fs.remove(`${routineDir}/${routine}.sql`);
+        }
+
+        const engine = this.engine;
+
+        for (const params of res) {
+            const routineName = params.name;
+            const sql = this.format(params);
+            const routineFile = `${routineDir}/${routineName}.sql`;
+
+            const oldSum = engine.getShaSum(routineName);
+            if (oldSum || saveSum) {
+                const shaSum = engine.shaSum(sql);
+                if (oldSum !== shaSum) {
+                    engine.setShaSum(
+                        this.objectType, schema, routineName, shaSum);
+                    update = true;
+                }
+            } else if (params.modified && engine.lastPull) {
+                if (params.modified > engine.lastPull)
+                    update = true;
+            } else if (await fs.pathExists(routineFile)) {
+                const currentSql = await fs.readFile(routineFile, 'utf8');
+                if (sql != currentSql)
+                    update = true;
+            } else
+                update = true;
+
+            if (update)
+                await fs.writeFile(routineFile, sql);
+        }
+    }
+
+    async query(schema, name) {
+        const {conn} = this;
+
+        const ops = [];
+        function addOp(col, value) {
+            ops.push(conn.format('?? = ?', [col, value]));
+        }
+        if (schema)
+            addOp(this.attrs.schemaCol, schema);
+        if (name)
+            addOp(this.attrs.nameCol, name);
+
+        const filter = {
+            toSqlString() {
+                return ops.join(' AND ');
+            }
+        }
+
+        const [res] = await conn.query(this.sql, [filter]);
+        return res;
+    }
+
+    format(params) {
+        const {conn, attrs} = this;
+
+        if (attrs.formatter)
+            attrs.formatter(params, conn);
+
+        if (attrs.escapeCols)
+        for (const escapeCol of attrs.escapeCols) {
+            if (params[escapeCol])
+                params[escapeCol] = conn.escape(params[escapeCol])
+        }
+
+        const split = params.definer.split('@');
+        params.schema = conn.escapeId(params.schema, true);
+        params.name = conn.escapeId(params.name, true);
+        params.definer =
+            `${conn.escapeId(split[0], true)}@${conn.escapeId(split[1], true)}`;
+
+        return this.template(params);
+    }
+}

package/lib/server.js

@@ -0,0 +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) {}
+    }
+};

package/lib/util.js

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

package/myt-clean.js

@@ -0,0 +1,52 @@
+
+const Myt = require('./myt');
+const Command = require('./lib/command');
+const fs = require('fs-extra');
+
+/**
+ * Cleans old applied versions.
+ */
+class Clean extends Command {
+    static usage = {
+        description: 'Cleans old applied versions'
+    };
+
+    static localOpts = {
+        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);
+
+            for (const oldVersion of oldVersions)
+                await fs.remove(`${opts.versionsDir}/${oldVersion}`,
+                    {recursive: true});
+
+            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-dump.js

@@ -0,0 +1,71 @@
+
+const Myt = require('./myt');
+const Command = require('./lib/command');
+const fs = require('fs-extra');
+
+class Dump extends Command {
+    static usage = {
+        description: 'Dumps structure and fixtures from remote',
+        operand: 'remote'
+    };
+
+    static localOpts = {
+        default: {
+            remote: 'production'
+        }
+    };
+
+    async run(myt, opts) {
+        const dumpStream = await myt.initDump('.dump.sql');
+
+        console.log('Dumping structure.');
+        let dumpArgs = [
+            '--default-character-set=utf8',
+            '--no-data',
+            '--comments',
+            '--triggers',
+            '--routines',
+            '--events',
+            '--databases'
+        ];
+        dumpArgs = dumpArgs.concat(opts.schemas);
+        await myt.runDump('docker-dump.sh', dumpArgs, dumpStream);
+
+        console.log('Dumping fixtures.');
+        await myt.dumpFixtures(dumpStream, opts.fixtures);
+
+        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'
+            ];
+            if (privs.where) args.push('--where', privs.where);
+            args = args.concat(['mysql'], privs.tables);
+            
+            await dumpStream.write('USE `mysql`;\n', 'utf8');
+            await myt.runDump('mysqldump', args, dumpStream);
+        }
+
+        await dumpStream.end();
+
+        console.log('Saving version.');
+        await myt.dbConnect();
+        const version = await myt.fetchDbVersion();
+        if (version) {
+            await fs.writeFile(
+                `${opts.dumpDir}/.dump.json`,
+                JSON.stringify(version)
+            );
+        }
+    }
+}
+
+module.exports = Dump;
+
+if (require.main === module)
+    new Myt().run(Dump);
+

package/myt-fixtures.js

@@ -0,0 +1,28 @@
+
+const Myt = require('./myt');
+const Command = require('./lib/command');
+
+class Fixtures extends Command {
+    static usage = {
+        description: 'Dumps local fixtures from database',
+        operand: 'remote'
+    };
+
+    static localOpts = {
+        default: {
+            remote: 'docker'
+        }
+    };
+
+    async run(myt, opts) {
+        const dumpStream = await myt.initDump('fixtures.sql');
+        await myt.dumpFixtures(dumpStream, opts.localFixtures, true);
+        await dumpStream.end();
+    }
+}
+
+module.exports = Fixtures;
+
+if (require.main === module)
+    new Myt().run(Fixtures);
+

package/myt-init.js

@@ -0,0 +1,25 @@
+
+const Myt = require('./myt');
+const Command = require('./lib/command');
+const fs = require('fs-extra');
+
+class Init extends Command {
+    static usage = {
+        description: 'Initialize an empty workspace'
+    };
+
+    async run(myt, opts) {
+        const templateDir = `${__dirname}/template`;
+        const templates = await fs.readdir(templateDir);
+        for (let template of templates) {
+            const dst = `${opts.mytDir}/${template}`;
+            if (!await fs.pathExists(dst))
+                await fs.copy(`${templateDir}/${template}`, dst);
+        }
+    }
+}
+
+module.exports = Init;
+
+if (require.main === module)
+    new Myt().run(Init);