adejs/utils/model.js

362 lines
8.9 KiB
JavaScript

const fs = require('fs');
const db = require('db');
const log = require('log');
const bc = require('bcryptjs');
let models = [];
function postgresToCamel(postgres) {
let ret = '';
for (let i = 0; i < postgres.length; i++) {
let c = postgres.charAt(i);
if (c === '_') {
i++;
ret += postgres.charAt(i).toUpperCase();
} else {
ret += c;
}
}
return ret;
}
function camelToPostgres(camelCase) {
let ret = '';
for (let i = 0; i < camelCase.length; i++) {
let c = camelCase.charAt(i);
if (c === c.toUpperCase()) {
ret += '_' + c.toLowerCase()
} else {
ret += c;
}
}
return ret;
}
function attributeToGetBy(attributeName) {
return 'getBy' +
attributeName.charAt(0).toUpperCase() + attributeName.substr(1);
}
module.exports.BaseModel = class {
constructor(name) {
models.push(this);
this.name = name;
this.fields = [];
}
addField(field) {
this.fields.push(field);
}
reinitialize(callback = () => {}) {
log.debug('Reinitializing ' + this.name);
let query =
"DROP TABLE IF EXISTS " +
camelToPostgres(this.name) + " CASCADE;";
db.query(query)
.then(res => this.createTable(callback))
.catch(err => log.dberror(err));
}
createTable(callback) {
let query = 'CREATE TABLE ' + camelToPostgres(this.name) + '(\n';
query += this.fields
.map(f => '\t' + f.getCreationString())
.join(',\n');
query += ');';
log.debug(query);
db.query(query)
.then(res => {
log.debug("Table " + camelToPostgres(this.name) + " created")
callback();
})
.catch(err => log.dberror(err));
}
}
module.exports.BaseField = class {
constructor(name, properties = {}) {
this.name = name;
this.unique = properties.unique || false;
this.notNull = properties.notNull || false;
this.default = properties.default;
}
getCreationString() {
return [
camelToPostgres(this.name),
this.getPostgresType(),
this.getFormattedPropeties(),
].join(' ');
}
getFormattedPropeties() {
let properties = [];
if (this.unique) {
properties.push('UNIQUE');
}
if (this.notNull) {
properties.push('NOT NULL');
}
return properties.join(' ');
}
createMutators() {
return {
get: this.createGetter(),
set: this.createSetter(),
};
}
createGetter() {
var self = this;
return function() {
return this['_' + self.name].value;
}
}
createSetter() {
var self = this;
return function(e) {
this['_' + self.name] = {
value: e,
changed: true,
};
}
}
}
module.exports.SmallIntegerField = class extends module.exports.BaseField {
constructor(name, properties = {}) {
super(name, properties);
}
getPostgresType() {
return "SMALLINT";
}
}
module.exports.SerialField = class extends module.exports.BaseField {
constructor(name, properties = {}) {
super(name, properties);
this.unique = true;
}
getPostgresType() {
return "SERIAL";
}
}
module.exports.TextField = class extends module.exports.BaseField {
constructor(name, properties = {}) {
super(name, properties);
}
getPostgresType() {
return "TEXT";
}
}
module.exports.PasswordField = class extends module.exports.BaseField {
constructor(name, properties = {}) {
super(name, properties);
}
getPostgresType() {
return 'TEXT';
}
createSetter() {
let self = this;
return function(e) {
this['_' + self.name] = {
value: bc.hashSync(e, 8),
changed: true,
};
}
}
}
module.exports.PasswordField.testSync = function(password, hash) {
return password === undefined ? false : bc.compareSync(password, hash);
}
module.exports.BoolField = class extends module.exports.BaseField {
constructor(name, properties) {
super(name, properties);
}
getPostgresType() {
return 'BOOLEAN';
}
}
module.exports.createClass = function(model) {
let ret = function(param) {
this._persisted = false;
for (let field of model.fields) {
this['_' + field.name] = {
value: field.default,
changed: true,
}
Object.defineProperty(this, field.name, field.createMutators());
}
};
for (let field of model.fields) {
if (!field.unique && field.name !== 'activationKey')
continue;
ret[attributeToGetBy(field.name)] = function(value, callback) {
let query =
'SELECT * FROM ' + camelToPostgres(model.name) +
' WHERE ' + camelToPostgres(field.name) +
'=$1;';
db
.query(query, [value])
.then(res => {
// Create the instance
let instance = new ret();
instance._persisted = true;
instance._setFromDbResult(res);
callback(undefined, instance);
})
.catch(err => callback(err));
}
}
ret.prototype._setFromDbResult = function(res) {
for (let field of model.fields) {
this['_' + field.name] = {
value: res.rows[0][camelToPostgres(field.name)],
changed: false,
};
}
}
ret.prototype.toJSON = function() {
let json = {};
for (let field of model.fields) {
json[field.name] = this[field.name]
}
return json;
}
ret.fromJSON = function(json) {
let result = new ret();
for (let field of model.fields) {
result[field.name] = json[field.name];
}
result._persisted = false;
return result;
}
ret.prototype.save = function(callback = () => {}) {
let fieldsToSave = [];
for (let field of model.fields) {
if (this['_' + field.name].changed) {
fieldsToSave.push({
field: field,
value: this[field.name],
});
}
}
fieldsToSave = fieldsToSave.filter((field) => {
return !(field.field instanceof module.exports.SerialField);
});
if (!this._persisted) {
// INSERT INTO
let queryBegin = 'INSERT INTO ' + camelToPostgres(model.name) + '('
let queryEnd = ' VALUES (';
queryBegin += fieldsToSave
.map(f => camelToPostgres(f.field.name))
.join(',');
queryEnd += fieldsToSave
.map((f, id) => '$' + (id + 1))
.join(',');
queryBegin += ')'
queryEnd += ') RETURNING *;'
let query = queryBegin + queryEnd;
db
.query(query, fieldsToSave.map(f => f.value))
.then(res => {
this._setFromDbResult(res);
this._persisted = true;
callback(undefined, this);
})
.catch(err => callback(err));
} else {
// UPDATE FROM
let query = 'UPDATE ' + camelToPostgres(model.name) + ' SET ';
query += fieldsToSave.map((f, i) => {
return camelToPostgres(f.field.name) + '=$' + (i+1);
}).join(',');
query += ' WHERE id=$' + (fieldsToSave.length + 1) + ' RETURNING *;'
db
.query(query, [...fieldsToSave.map(f => f.value), this.id])
.then(res => {
this._setFromDbResult(res);
this._persisted = true;
callback(undefined, this);
})
.catch(err => callback(err));
}
}
return ret;
}
module.exports.reinitialize = function(callback = () => {}) {
let finished = models.map(m => false);
for (let i = 0; i < models.length; i++) {
let model = models[i];
model.reinitialize(() => {
finished[i] = true;
if (finished.reduce((a, b) => a && b, true)) {
callback();
}
});
}
}
module.exports.load = function(controllersDir) {
fs.readdirSync(controllersDir).forEach(function(name) {
let path = controllersDir + '/' + name + '/models.js';
try {
fs.accessSync(path);
} catch (e) {
return;
}
require(path);
});
}