468 lines
13 KiB
JavaScript
468 lines
13 KiB
JavaScript
var safeRequire = require('../utils').safeRequire;
|
|
|
|
/**
|
|
* Module dependencies
|
|
*/
|
|
var mysql = safeRequire('mysql');
|
|
|
|
exports.initialize = function initializeSchema(schema, callback) {
|
|
if (!mysql) return;
|
|
|
|
var s = schema.settings;
|
|
schema.client = mysql.createClient({
|
|
host: s.host || 'localhost',
|
|
port: s.port || 3306,
|
|
user: s.username,
|
|
password: s.password,
|
|
database: s.database,
|
|
debug: s.debug
|
|
});
|
|
|
|
schema.adapter = new MySQL(schema.client);
|
|
// schema.client.query('SET TIME_ZONE = "+04:00"', callback);
|
|
process.nextTick(callback);
|
|
};
|
|
|
|
function MySQL(client) {
|
|
this._models = {};
|
|
this.client = client;
|
|
}
|
|
|
|
MySQL.prototype.define = function (descr) {
|
|
this._models[descr.model.modelName] = descr;
|
|
};
|
|
|
|
MySQL.prototype.defineProperty = function (model, prop, params) {
|
|
this._models[model].properties[prop] = params;
|
|
};
|
|
|
|
MySQL.prototype.query = function (sql, callback) {
|
|
var time = Date.now();
|
|
var log = this.log;
|
|
if (typeof callback !== 'function') throw new Error('callback should be a function');
|
|
this.client.query(sql, function (err, data) {
|
|
log(sql, time);
|
|
callback(err, data);
|
|
});
|
|
};
|
|
|
|
MySQL.prototype.save = function (model, data, callback) {
|
|
var sql = 'UPDATE ' + model + ' SET ' + this.toFields(model, data) +
|
|
' WHERE id = ' + data.id;
|
|
|
|
this.query(sql, function (err) {
|
|
callback(err);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Must invoke callback(err, id)
|
|
*/
|
|
MySQL.prototype.create = function (model, data, callback) {
|
|
var fields = this.toFields(model, data);
|
|
var sql = 'INSERT ' + model;
|
|
if (fields) {
|
|
sql += ' SET ' + fields;
|
|
} else {
|
|
sql += ' VALUES ()';
|
|
}
|
|
this.query(sql, function (err, info) {
|
|
callback(err, info && info.insertId);
|
|
});
|
|
};
|
|
|
|
MySQL.prototype.toFields = function (model, data) {
|
|
var fields = [];
|
|
var props = this._models[model].properties;
|
|
Object.keys(data).forEach(function (key) {
|
|
if (props[key]) {
|
|
fields.push('`' + key.replace(/\./g, '`.`') + '` = ' + this.toDatabase(props[key], data[key]));
|
|
}
|
|
}.bind(this));
|
|
return fields.join(',');
|
|
};
|
|
|
|
function dateToMysql(val) {
|
|
return val.getUTCFullYear() + '-' +
|
|
fillZeros(val.getUTCMonth() + 1) + '-' +
|
|
fillZeros(val.getUTCDate()) + ' ' +
|
|
fillZeros(val.getUTCHours()) + ':' +
|
|
fillZeros(val.getUTCMinutes()) + ':' +
|
|
fillZeros(val.getUTCSeconds());
|
|
|
|
function fillZeros(v) {
|
|
return v < 10 ? '0' + v : v;
|
|
}
|
|
}
|
|
|
|
MySQL.prototype.toDatabase = function (prop, val) {
|
|
if (val === null) return 'NULL';
|
|
if (val.constructor.name === 'Object') {
|
|
var operator = Object.keys(val)[0]
|
|
val = val[operator];
|
|
if (operator === 'between') {
|
|
return this.toDatabase(prop, val[0]) +
|
|
' AND ' +
|
|
this.toDatabase(prop, val[1]);
|
|
} else if (operator == 'inq' || operator == 'nin') {
|
|
if (!(val.propertyIsEnumerable('length')) && typeof val === 'object' && typeof val.length === 'number') { //if value is array
|
|
return val.join(',');
|
|
} else {
|
|
return val;
|
|
}
|
|
}
|
|
}
|
|
if (prop.type.name === 'Number') return val;
|
|
if (prop.type.name === 'Date') {
|
|
if (!val) return 'NULL';
|
|
if (!val.toUTCString) {
|
|
val = new Date(val);
|
|
}
|
|
return '"' + dateToMysql(val) + '"';
|
|
}
|
|
if (prop.type.name == "Boolean") return val ? 1 : 0;
|
|
return this.client.escape(val.toString());
|
|
};
|
|
|
|
MySQL.prototype.fromDatabase = function (model, data) {
|
|
if (!data) return null;
|
|
var props = this._models[model].properties;
|
|
Object.keys(data).forEach(function (key) {
|
|
var val = data[key];
|
|
if (props[key]) {
|
|
if (props[key].type.name === 'Date') {
|
|
val = new Date(val.toString().replace(/GMT.*$/, 'GMT'));
|
|
}
|
|
}
|
|
data[key] = val;
|
|
});
|
|
return data;
|
|
};
|
|
|
|
MySQL.prototype.exists = function (model, id, callback) {
|
|
var sql = 'SELECT 1 FROM ' + model + ' WHERE id = ' + id + ' LIMIT 1';
|
|
this.query(sql, function (err, data) {
|
|
if (err) return callback(err);
|
|
callback(null, data.length === 1);
|
|
});
|
|
};
|
|
|
|
MySQL.prototype.find = function find(model, id, callback) {
|
|
var sql = 'SELECT * FROM ' + model + ' WHERE id = ' + id + ' LIMIT 1';
|
|
this.query(sql, function (err, data) {
|
|
if (data && data.length === 1) {
|
|
data[0].id = id;
|
|
} else {
|
|
data = [null];
|
|
}
|
|
callback(err, this.fromDatabase(model, data[0]));
|
|
}.bind(this));
|
|
};
|
|
|
|
MySQL.prototype.destroy = function destroy(model, id, callback) {
|
|
var sql = 'DELETE FROM ' + model + ' WHERE id = ' + id + ' LIMIT 1';
|
|
this.query(sql, function (err) {
|
|
callback(err);
|
|
});
|
|
};
|
|
|
|
MySQL.prototype.all = function all(model, filter, callback) {
|
|
|
|
var sql = 'SELECT * FROM ' + model;
|
|
var self = this;
|
|
var props = this._models[model].properties;
|
|
|
|
if (filter) {
|
|
|
|
if (filter.where) {
|
|
sql += ' ' + buildWhere(filter.where);
|
|
}
|
|
|
|
if (filter.order) {
|
|
sql += ' ' + buildOrderBy(filter.order);
|
|
}
|
|
|
|
if (filter.limit) {
|
|
sql += ' ' + buildLimit(filter.limit, filter.offset || 0);
|
|
}
|
|
|
|
}
|
|
|
|
this.query(sql, function (err, data) {
|
|
if (err) {
|
|
return callback(err, []);
|
|
}
|
|
callback(null, data.map(function (obj) {
|
|
return self.fromDatabase(model, obj);
|
|
}));
|
|
}.bind(this));
|
|
|
|
return sql;
|
|
|
|
function buildWhere(conds) {
|
|
var cs = [];
|
|
Object.keys(conds).forEach(function (key) {
|
|
var keyEscaped = '`' + key.replace(/\./g, '`.`') + '`'
|
|
var val = self.toDatabase(props[key], conds[key]);
|
|
if (conds[key] === null) {
|
|
cs.push(keyEscaped + ' IS NULL');
|
|
} else if (conds[key].constructor.name === 'Object') {
|
|
var condType = Object.keys(conds[key])[0];
|
|
var sqlCond = keyEscaped;
|
|
switch (condType) {
|
|
case 'gt':
|
|
sqlCond += ' > ';
|
|
break;
|
|
case 'gte':
|
|
sqlCond += ' >= ';
|
|
break;
|
|
case 'lt':
|
|
sqlCond += ' < ';
|
|
break;
|
|
case 'lte':
|
|
sqlCond += ' <= ';
|
|
break;
|
|
case 'between':
|
|
sqlCond += ' BETWEEN ';
|
|
break;
|
|
case 'inq':
|
|
sqlCond += ' IN ';
|
|
break;
|
|
case 'nin':
|
|
sqlCond += ' NOT IN ';
|
|
break;
|
|
case 'neq':
|
|
sqlCond + ' != ';
|
|
break;
|
|
}
|
|
sqlCond += (condType == 'inq' || condType == 'nin') ? '(' + val + ')' : val;
|
|
cs.push(sqlCond);
|
|
} else {
|
|
cs.push(keyEscaped + ' = ' + val);
|
|
}
|
|
});
|
|
return 'WHERE ' + cs.join(' AND ');
|
|
}
|
|
|
|
function buildOrderBy(order) {
|
|
if (typeof order === 'string') order = [order];
|
|
return 'ORDER BY ' + order.join(', ');
|
|
}
|
|
|
|
function buildLimit(limit, offset) {
|
|
return 'LIMIT ' + (offset ? (offset + ', ' + limit) : limit);
|
|
}
|
|
|
|
};
|
|
|
|
MySQL.prototype.destroyAll = function destroyAll(model, callback) {
|
|
this.query('DELETE FROM ' + model, function (err) {
|
|
if (err) {
|
|
return callback(err, []);
|
|
}
|
|
callback(err);
|
|
}.bind(this));
|
|
};
|
|
|
|
MySQL.prototype.count = function count(model, callback, where) {
|
|
var self = this;
|
|
var props = this._models[model].properties;
|
|
|
|
this.query('SELECT count(*) as cnt FROM ' + model + buildWhere(where), function (err, res) {
|
|
callback(err, err ? null : res[0].cnt);
|
|
});
|
|
|
|
function buildWhere(conds) {
|
|
var cs = [];
|
|
Object.keys(conds || {}).forEach(function (key) {
|
|
var keyEscaped = '`' + key.replace(/\./g, '`.`') + '`'
|
|
if (conds[key] === null) {
|
|
cs.push(keyEscaped + ' IS NULL');
|
|
} else {
|
|
cs.push(keyEscaped + ' = ' + self.toDatabase(props[key], conds[key]));
|
|
}
|
|
});
|
|
return cs.length ? ' WHERE ' + cs.join(' AND ') : '';
|
|
}
|
|
};
|
|
|
|
MySQL.prototype.updateAttributes = function updateAttrs(model, id, data, cb) {
|
|
data.id = id;
|
|
this.save(model, data, cb);
|
|
};
|
|
|
|
MySQL.prototype.disconnect = function disconnect() {
|
|
this.client.end();
|
|
};
|
|
|
|
MySQL.prototype.automigrate = function (cb) {
|
|
var self = this;
|
|
var wait = 0;
|
|
Object.keys(this._models).forEach(function (model) {
|
|
wait += 1;
|
|
self.dropTable(model, function () {
|
|
self.createTable(model, function (err) {
|
|
if (err) console.log(err);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
function done() {
|
|
if (--wait === 0 && cb) {
|
|
cb();
|
|
}
|
|
}
|
|
};
|
|
|
|
MySQL.prototype.autoupdate = function (cb) {
|
|
var self = this;
|
|
var wait = 0;
|
|
Object.keys(this._models).forEach(function (model) {
|
|
wait += 1;
|
|
self.query('SHOW FIELDS FROM ' + model, function (err, fields) {
|
|
if (!err && fields.length) {
|
|
self.alterTable(model, fields, done);
|
|
} else {
|
|
self.createTable(model, done);
|
|
}
|
|
});
|
|
});
|
|
|
|
function done(err) {
|
|
if (err) {
|
|
console.log(err);
|
|
}
|
|
if (--wait === 0 && cb) {
|
|
cb();
|
|
}
|
|
}
|
|
};
|
|
|
|
MySQL.prototype.isActual = function (cb) {
|
|
var ok = false;
|
|
var self = this;
|
|
var wait = 0;
|
|
Object.keys(this._models).forEach(function (model) {
|
|
wait += 1;
|
|
self.query('SHOW FIELDS FROM ' + model, function (err, fields) {
|
|
self.alterTable(model, fields, done, true);
|
|
});
|
|
});
|
|
|
|
function done(err, needAlter) {
|
|
if (err) {
|
|
console.log(err);
|
|
}
|
|
ok = ok || needAlter;
|
|
if (--wait === 0 && cb) {
|
|
cb(null, !ok);
|
|
}
|
|
}
|
|
};
|
|
|
|
MySQL.prototype.alterTable = function (model, actualFields, done, checkOnly) {
|
|
var self = this;
|
|
var m = this._models[model];
|
|
var propNames = Object.keys(m.properties).filter(function (name) {
|
|
return !!m.properties[name];
|
|
});
|
|
var sql = [];
|
|
|
|
// change/add new fields
|
|
propNames.forEach(function (propName) {
|
|
var found;
|
|
actualFields.forEach(function (f) {
|
|
if (f.Field === propName) {
|
|
found = f;
|
|
}
|
|
});
|
|
|
|
if (found) {
|
|
actualize(propName, found);
|
|
} else {
|
|
sql.push('ADD COLUMN `' + propName + '` ' + self.propertySettingsSQL(model, propName));
|
|
}
|
|
});
|
|
|
|
// drop columns
|
|
actualFields.forEach(function (f) {
|
|
var notFound = !~propNames.indexOf(f.Field);
|
|
if (f.Field === 'id') return;
|
|
if (notFound || !m.properties[f.Field]) {
|
|
sql.push('DROP COLUMN `' + f.Field + '`');
|
|
}
|
|
});
|
|
|
|
if (sql.length) {
|
|
if (checkOnly) {
|
|
done(null, true);
|
|
} else {
|
|
this.query('ALTER TABLE `' + model + '` ' + sql.join(',\n'), done);
|
|
}
|
|
} else {
|
|
done();
|
|
}
|
|
|
|
function actualize(propName, oldSettings) {
|
|
var newSettings = m.properties[propName];
|
|
if (newSettings && changed(newSettings, oldSettings)) {
|
|
sql.push('CHANGE COLUMN `' + propName + '` `' + propName + '` ' + self.propertySettingsSQL(model, propName));
|
|
}
|
|
}
|
|
|
|
function changed(newSettings, oldSettings) {
|
|
if (oldSettings.Null === 'YES' && (newSettings.allowNull === false || newSettings.null === false)) return true;
|
|
if (oldSettings.Null === 'NO' && !(newSettings.allowNull === false || newSettings.null === false)) return true;
|
|
if (oldSettings.Type.toUpperCase() !== datatype(newSettings)) return true;
|
|
return false;
|
|
}
|
|
};
|
|
|
|
MySQL.prototype.dropTable = function (model, cb) {
|
|
this.query('DROP TABLE IF EXISTS ' + model, cb);
|
|
};
|
|
|
|
MySQL.prototype.createTable = function (model, cb) {
|
|
this.query('CREATE TABLE ' + model +
|
|
' (\n ' + this.propertiesSQL(model) + '\n)', cb);
|
|
};
|
|
|
|
MySQL.prototype.propertiesSQL = function (model) {
|
|
var self = this;
|
|
var sql = ['`id` INT(11) NOT NULL AUTO_INCREMENT UNIQUE PRIMARY KEY'];
|
|
Object.keys(this._models[model].properties).forEach(function (prop) {
|
|
sql.push('`' + prop + '` ' + self.propertySettingsSQL(model, prop));
|
|
});
|
|
return sql.join(',\n ');
|
|
|
|
};
|
|
|
|
MySQL.prototype.propertySettingsSQL = function (model, prop) {
|
|
var p = this._models[model].properties[prop];
|
|
return datatype(p) + ' ' +
|
|
(p.allowNull === false || p['null'] === false ? 'NOT NULL' : 'NULL');
|
|
};
|
|
|
|
function datatype(p) {
|
|
var dt = '';
|
|
switch (p.type.name) {
|
|
case 'String':
|
|
dt = 'VARCHAR(' + (p.limit || 255) + ')';
|
|
break;
|
|
case 'Text':
|
|
dt = 'TEXT';
|
|
break;
|
|
case 'Number':
|
|
dt = 'INT(' + (p.limit || 11) + ')';
|
|
break;
|
|
case 'Date':
|
|
dt = 'DATETIME';
|
|
break;
|
|
case 'Boolean':
|
|
dt = 'TINYINT(1)';
|
|
break;
|
|
}
|
|
return dt;
|
|
}
|