first commit

app/utils/cache_key_generator.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function generateCacheKey(database, affectedTables) {
+    return database + ":" + affectedTables.join(',');
+};

app/utils/content_disposition.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = function getContentDisposition(formatter, filename, inline) {
+    var ext = formatter.getFileExtension();
+    var time = new Date().toUTCString();
+    return ( inline ? 'inline' : 'attachment' ) + '; filename=' + filename + '.' + ext + '; ' +
+        'modification-date="' + time + '";';
+};

app/utils/date_to_json.js

@@ -0,0 +1,19 @@
+'use strict';
+
+// jshint ignore:start
+function pad(n) {
+    return n < 10 ? '0' + n : n;
+}
+
+Date.prototype.toJSON = function() {
+    var s = this.getFullYear() + '-' + pad(this.getMonth() + 1) + '-' + pad(this.getDate()) + 'T' +
+        pad(this.getHours()) + ':' + pad(this.getMinutes()) + ':' + pad(this.getSeconds());
+    var offset = this.getTimezoneOffset();
+    if (offset === 0) {
+        s += 'Z';
+    } else {
+        s += ( offset < 0 ? '+' : '-' ) + pad(Math.abs(offset / 60)) + pad(Math.abs(offset % 60));
+    }
+    return s;
+};
+// jshint ignore:end

app/utils/filename_sanitizer.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var path = require('path');
+
+module.exports = function sanitize_filename(filename) {
+  filename = path.basename(filename, path.extname(filename));
+  filename = filename.replace(/[;()\[\]<>'"\s]/g, '_');
+  return filename;
+};

app/utils/md5.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var crypto = require('crypto');
+
+module.exports = function generateMD5(data){
+    var hash = crypto.createHash('md5');
+    hash.update(data);
+    return hash.digest('hex');
+};

app/utils/no_cache.js

@@ -0,0 +1,49 @@
+'use strict';
+
+/**
+ * This module provides an object with the interface of an LRU cache
+ * but that actually does not store anything.
+ *
+ * See https://github.com/isaacs/node-lru-cache/tree/v2.5.0
+ */
+
+function NoCache() {
+}
+
+module.exports = NoCache;
+
+NoCache.prototype.set = function (/* key, value */) {
+    return true;
+};
+
+NoCache.prototype.get = function (/* key */) {
+    return undefined;
+};
+
+NoCache.prototype.peek = function (/* key */) {
+    return undefined;
+};
+
+NoCache.prototype.del = function (/* key */) {
+    return undefined;
+};
+
+NoCache.prototype.reset = function () {
+    return undefined;
+};
+
+NoCache.prototype.has = function (/* key */) {
+    return false;
+};
+
+NoCache.prototype.forEach = function (/* fn, thisp */) {
+    return undefined;
+};
+
+NoCache.prototype.keys = function () {
+    return [];
+};
+
+NoCache.prototype.values = function () {
+    return [];
+};

app/utils/query_info.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const COPY_FORMATS = ['TEXT', 'CSV', 'BINARY'];
+
+module.exports = {
+    getFormatFromCopyQuery(copyQuery) {
+        let format = 'TEXT'; // Postgres default format
+
+        copyQuery = copyQuery.toUpperCase();
+
+        if (!copyQuery.startsWith("COPY ")) {
+            return false;
+        }
+
+        if(copyQuery.includes(' WITH') && copyQuery.includes('FORMAT ')) {
+            const regex = /\bFORMAT\s+(\w+)/;
+            const result = regex.exec(copyQuery);
+
+            if (result && result.length === 2) {
+                if (COPY_FORMATS.includes(result[1])) {
+                    format = result[1];
+                    format = format.toUpperCase();
+                } else {
+                    format = false;
+                }
+            }
+        }
+
+        return format;
+    }
+};

app/utils/query_may_write.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var sqlQueryMayWriteRegex = new RegExp("\\b(alter|insert|update|delete|create|drop|reindex|truncate|refresh)\\b", "i");
+
+/**
+ * This is a fuzzy check, the return could be true even if the query doesn't really write anything. But you can be
+ * pretty sure of a false return.
+ *
+ * @param sql The SQL statement to check against
+ * @returns {boolean} Return true of the given query may write to the database
+ */
+module.exports = function queryMayWrite(sql) {
+    return sqlQueryMayWriteRegex.test(sql);
+};

app/utils/table_cache_factory.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var LRU = require('lru-cache');
+var NoCache = require('./no_cache');
+
+/**
+ * This module abstracts the creation of a tableCache,
+ * depending on the configuration passed along
+ */
+
+function TableCacheFactory() {
+}
+
+module.exports = TableCacheFactory;
+
+TableCacheFactory.prototype.build = function (settings) {
+    var enabled = settings.tableCacheEnabled || false;
+    var tableCache = null;
+
+    if(enabled) {
+        tableCache = LRU({
+            // store no more than these many items in the cache
+            max: settings.tableCacheMax || 8192,
+            // consider entries expired after these many milliseconds (10 minutes by default)
+            maxAge: settings.tableCacheMaxAge || 1000*60*10
+        });
+    } else {
+        tableCache = new NoCache();
+    }
+
+    return tableCache;
+};