@verdnatura/myt 1.5.6 → 1.5.8

package/README.md

@@ -45,6 +45,8 @@ Database versioning commands:
  * **pull**: Incorporate database routine changes into workspace.
  * **push**: Apply changes into database.
  * **version**: Creates a new version.
+ * **create**: Creates a new routine file.
+ * **clean**: Cleans old versions.
 
 Local server management commands:
 
@@ -195,6 +197,14 @@ name mixing a color with a plant name.
 $ myt version [<name>]
 ```
 
+### create
+
+Creates a new routine file with a default template.
+
+```text
+$ myt create [-t <type>] <schema>.<name>
+```
+
 ### clean
 
 Cleans all already applied versions older than  *maxOldVersions*.

package/exporters/event.ejs

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

package/exporters/event.js

@@ -8,6 +8,12 @@ module.exports = {
         'executeAt',
         'comment'
     ],
+    defaults: {
+        type: 'RECURRING',
+        intervalValue: 1,
+        intervalField: 'DAY',
+        onCompletion: 'PRESERVE'
+    },
     formatter(params) {
         let status;
         switch(params.status){

package/exporters/function.ejs

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

package/exporters/function.js

@@ -5,6 +5,10 @@ module.exports = {
     escapeCols: [
         'comment'
     ],
+    defaults: {
+        returns: 'INT',
+        isDeterministic: 'NO'
+    },
     formatter(params) {
         let dataAccess;
         switch(params.dataAccess) {

package/exporters/procedure.ejs

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

package/exporters/trigger.js

@@ -1,5 +1,10 @@
 
 module.exports = {
     schemaCol: 'TRIGGER_SCHEMA',
-    nameCol: 'TRIGGER_NAME'
+    nameCol: 'TRIGGER_NAME',
+    defaults: {
+        actionTiming: 'AFTER',
+        actionType: 'INSERT',
+        table: 'table'
+    }
 };

package/exporters/view.ejs

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

package/exporters/view.js

@@ -4,6 +4,10 @@ const sqlFormatter = require('@sqltools/formatter');
 module.exports = {
     schemaCol: 'TABLE_SCHEMA',
     nameCol: 'TABLE_NAME',
+    defaults: {
+        securityType: 'DEFINER',
+        checkOption: 'NONE'
+    },
     formatter(params) {
         params.definition = sqlFormatter.format(params.definition, {
             indent: '\t',

package/lib/command.js

@@ -2,12 +2,9 @@
  * Base class for Myt commands.
  */
 module.exports = class MytCommand {
-    get usage() {
-        return {};
-    }
-
-    get localOpts() {
-        return {};
+    constructor(myt, opts) {
+        this.myt = myt;
+        this.opts = opts;
     }
 
     async run(myt, opts) {

package/lib/conn.js

@@ -0,0 +1,141 @@
+const fs = require('fs-extra');
+
+/**
+ * Executes an SQL script.
+ *
+ * @param {Connection} conn MySQL connection object
+ * @returns {Array<Result>} The resultset
+ */
+async function 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 function 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
+ */
+function 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 = {
+    queryFromFile,
+    multiQuery,
+    querySplit,
+    tokens
+};

package/lib/dumper.js

@@ -0,0 +1,83 @@
+const docker = require('./docker');
+const fs = require('fs-extra');
+const path = require('path');
+const SqlString = require('sqlstring');
+
+module.exports = class Dumper {
+    constructor(opts) {
+        this.opts = opts;
+    }
+
+    async init(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);
+
+        const buidDir = path.join(__dirname, '..',)
+        await docker.build(buidDir, {
+            tag: 'myt/client',
+            file: path.join(buidDir, 'server', 'Dockerfile.client')
+        }, this.opts.debug);
+
+        this.dumpStream = dumpStream;
+    }
+
+    async use(schema) {
+        await this.dumpStream.write(
+            `USE ${SqlString.escapeId(schema, true)};\n`,
+            'utf8'
+        );
+    }
+
+    async dumpFixtures(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) {
+            await this.use(schema);
+            const args = fixturesArgs.concat([schema], tables[schema]);
+            await this.runDump('mysqldump', args, this.dumpStream);
+        }
+    }
+
+    async runDump(command, args) {
+        const iniPath = path.join(this.opts.subdir || '', 'remotes', this.opts.iniFile);
+        const myArgs = [
+            `--defaults-file=${iniPath}`
+        ];
+        const execOptions = {
+            stdio: [
+                process.stdin,
+                this.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);
+    }
+
+    async end() {
+        await this.dumpStream.end();
+    }
+}

package/lib/exporter-engine.js

@@ -1,4 +1,3 @@
-
 const shajs = require('sha.js');
 const fs = require('fs-extra');
 const Exporter = require('./exporter');
@@ -36,7 +35,7 @@ module.exports = class ExporterEngine {
         ];
 
         for (const type of types) {
-            const exporter = new Exporter(this, type, this.conn);
+            const exporter = new Exporter(type);
             await exporter.init();
 
             this.exporters.push(exporter);
@@ -46,7 +45,7 @@ module.exports = class ExporterEngine {
 
     async fetchRoutine(type, schema, name) {
         const exporter = this.exporterMap[type];
-        const [row] = await exporter.query(schema, name);
+        const [row] = await exporter.query(this.conn, schema, name);
         return row && exporter.format(row);
     }
 

package/lib/exporter.js

@@ -1,13 +1,10 @@
-
 const ejs = require('ejs');
 const fs = require('fs-extra');
+const SqlString = require('sqlstring');
 
 module.exports = class Exporter {
-    constructor(engine, objectType, conn) {
-        this.engine = engine;
+    constructor(objectType) {
         this.objectType = objectType;
-        this.dstDir = `${objectType}s`;
-        this.conn = conn;
     }
 
     async init() {
@@ -19,60 +16,7 @@ module.exports = class Exporter {
         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;
-
+    async query(conn, schema, name) {
         const ops = [];
         function addOp(col, value) {
             ops.push(conn.format('?? = ?', [col, value]));
@@ -93,22 +37,24 @@ module.exports = class Exporter {
     }
 
     format(params) {
-        const {conn, attrs} = this;
+        const {attrs} = this;
+        params = Object.assign({}, attrs.defaults, params);
 
         if (attrs.formatter)
-            attrs.formatter(params, conn);
+            attrs.formatter(params);
 
         if (attrs.escapeCols)
         for (const escapeCol of attrs.escapeCols) {
             if (params[escapeCol])
-                params[escapeCol] = conn.escape(params[escapeCol])
+                params[escapeCol] = SqlString.escape(params[escapeCol])
         }
 
         const split = params.definer.split('@');
-        params.schema = conn.escapeId(params.schema, true);
-        params.name = conn.escapeId(params.name, true);
+        params.schema = SqlString.escapeId(params.schema, true);
+        params.name = SqlString.escapeId(params.name, true);
         params.definer =
-            `${conn.escapeId(split[0], true)}@${conn.escapeId(split[1], true)}`;
+            SqlString.escapeId(split[0], true) + '@' +
+            SqlString.escapeId(split[1], true);
 
         return this.template(params);
     }

package/lib/repo.js

@@ -0,0 +1,29 @@
+const nodegit = require('nodegit');
+
+async function 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 function getUnstaged(repo) {
+    const Diff = nodegit.Diff;
+    return await Diff.indexToWorkdir(repo, null, {
+        flags: Diff.OPTION.SHOW_UNTRACKED_CONTENT
+            | Diff.OPTION.RECURSE_UNTRACKED_DIRS
+    });
+}
+
+module.exports = {
+    getStaged,
+    getUnstaged
+};

package/lib/util.js

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

package/myt-clean.js

@@ -1,4 +1,3 @@
-
 const Myt = require('./myt');
 const Command = require('./lib/command');
 const fs = require('fs-extra');
@@ -11,7 +10,7 @@ class Clean extends Command {
         description: 'Cleans old applied versions'
     };
 
-    static localOpts = {
+    static opts = {
         default: {
             remote: 'production'
         }

package/myt-create.js

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