/**
 * Module dependencies
 */
var util = require('util');1
var jutil = require('./jutil');1
var Validatable = require('./validatable').Validatable;1
var Hookable = require('./hookable').Hookable;1
var DEFAULT_CACHE_LIMIT = 1000;1
exports.AbstractClass = AbstractClass;1
jutil.inherits(AbstractClass, Validatable);1
jutil.inherits(AbstractClass, Hookable);1
/**
 * Abstract class - base class for all persist objects
 * provides **common API** to access any database adapter.
 * This class describes only abstract behavior layer, refer to `lib/adapters/*.js`
 * to learn more about specific adapter implementations
 *
 * `AbstractClass` mixes `Validatable` and `Hookable` classes methods
 *
 * @constructor
 * @param {Object} data - initial object data
 */
function AbstractClass(data) {
    this._initProperties(data, true);971
}
AbstractClass.prototype._initProperties = function (data, applySetters) {
    var self = this;1659
    var ctor = this.constructor;1659
    var ds = ctor.schema.definitions[ctor.modelName];1659
    var properties = ds.properties;1659
    data = data || {};1659
    if (data.id) {
        defineReadonlyProp(this, 'id', data.id);659
    }
    Object.defineProperty(this, 'cachedRelations', {
        writable: true,
        enumerable: false,
        configurable: true,
        value: {}
    });1659
    Object.keys(properties).forEach(function (attr) {
        var _attr    = '_' + attr,
            attr_was = attr + '_was';9250
        // Hidden property to store currrent value
        Object.defineProperty(this, _attr, {
            writable: true,
            enumerable: false,
            configurable: true,
            value: isdef(data[attr]) ? data[attr] :
            (isdef(this[attr]) ? this[attr] : (
                getDefault(attr)
            ))
        });9250
        // Public setters and getters
        Object.defineProperty(this, attr, {
            get: function () {
                if (ctor.getter[attr]) {
                    return ctor.getter[attr].call(this);
                } else {
                    return this[_attr];4586
                }
            },
            set: function (value) {
                if (ctor.setter[attr]) {
                    ctor.setter[attr].call(this, value);8
                } else {
                    this[_attr] = value;105
                }
            },
            configurable: true,
            enumerable: true
        });9250
        if (data.hasOwnProperty(attr)) {
            if (applySetters && ctor.setter[attr]) {
                ctor.setter[attr].call(this, data[attr]);24
            }
            // Getter for initial property
            Object.defineProperty(this, attr_was, {
                writable: true,
                value: this[_attr],
                configurable: true,
                enumerable: false
            });3394
        }
    }.bind(this));1659
    function getDefault(attr) {
        var def = properties[attr]['default']
        if (isdef(def)) {
            if (typeof def === 'function') {
                return def();574
            } else {
                return def;659
            }
        } else {
            return null;3721
        }
    }
    this.trigger("initialize");1659
};1
AbstractClass.setter = {};1
AbstractClass.getter = {};1
/**
 * @param {String} prop - property name
 * @param {Object} params - various property configuration
 */
AbstractClass.defineProperty = function (prop, params) {
    this.schema.defineProperty(this.modelName, prop, params);5
};1
AbstractClass.whatTypeName = function (propName) {
    var ds = this.schema.definitions[this.modelName];32
    return ds.properties[propName].type.name;32
};1
AbstractClass.prototype.whatTypeName = function (propName) {
    return this.constructor.whatTypeName(propName);16
};1
/**
 * Create new instance of Model class, saved in database
 *
 * @param data [optional]
 * @param callback(err, obj)
 * callback called with arguments:
 *
 *   - err (null or Error)
 *   - instance (null or Model)
 */
AbstractClass.create = function (data, callback) {
    if (stillConnecting(this.schema, this, arguments)) return;292
    var modelName = this.modelName;292
    if (typeof data === 'function') {
        callback = data;41
        data = {};41
    }
    if (typeof callback !== 'function') {
        callback = function () {};8
    }
    var obj = null;292
    // if we come from save
    if (data instanceof AbstractClass && !data.id) {
        obj = data;44
        data = obj.toObject(true);44
        this.prototype._initProperties.call(obj, data, false);44
        create();44
    } else {
        obj = new this(data);248
        data = obj.toObject(true);248
        // validation required
        obj.isValid(function (valid) {
            if (!valid) {
                callback(new Error('Validation error'), obj);1
            } else {
                create();247
            }
        });248
    }
    function create() {
        obj.trigger('create', function (done) {
            this._adapter().create(modelName, data, function (err, id) {
                if (id) {
                    defineReadonlyProp(obj, 'id', id);290
                    addToCache(this.constructor, obj);290
                }
                done.call(this, function () {
                    if (callback) {
                        callback(err, obj);290
                    }
                });290
            }.bind(this));290
        });291
    }
};1
function stillConnecting(schema, obj, args) {
    if (schema.connected) return false;
    var method = args.callee;
    schema.on('connected', function () {
        method.apply(obj, [].slice.call(args));
    });
    return true;
};1
/**
 * Update or insert
 */
AbstractClass.upsert = AbstractClass.updateOrCreate = function upsert(data, callback) {
    if (stillConnecting(this.schema, this, arguments)) return;20
    var Model = this;20
    if (!data.id) return this.create(data, callback);12
    if (this.schema.adapter.updateOrCreate) {
        var inst = new Model(data);12
        this.schema.adapter.updateOrCreate(Model.modelName, inst.toObject(), function (err, data) {
            var obj;12
            if (data) {
                inst._initProperties(data);12
                obj = inst;12
            } else {
                obj = null;
            }
            if (obj) {
                addToCache(Model, obj);12
            }
            callback(err, obj);12
        });12
    } else {
        this.find(data.id, function (err, inst) {
            if (err) return callback(err);
            if (inst) {
                inst.updateAttributes(data, callback);
            } else {
                var obj = new Model(data);
                obj.save(data, callback);
            }
        });
    }
};1
/**
 * Check whether object exitst in database
 *
 * @param {id} id - identifier of object (primary key value)
 * @param {Function} cb - callbacl called with (err, exists: Bool)
 */
AbstractClass.exists = function exists(id, cb) {
    if (stillConnecting(this.schema, this, arguments)) return;24
    if (id) {
        this.schema.adapter.exists(this.modelName, id, cb);24
    } else {
        cb(new Error('Model::exists requires positive id argument'));
    }
};1
/**
 * Find object by id
 *
 * @param {id} id - primary key value
 * @param {Function} cb - callback called with (err, instance)
 */
AbstractClass.find = function find(id, cb) {
    if (stillConnecting(this.schema, this, arguments)) return;68
    this.schema.adapter.find(this.modelName, id, function (err, data) {
        var obj = null;68
        if (data) {
            var cached = getCached(this, data.id);60
            if (cached) {
                obj = cached;
                substractDirtyAttributes(obj, data);
                // maybe just obj._initProperties(data); instead of
                this.prototype._initProperties.call(obj, data);
            } else {
                data.id = id;60
                obj = new this();60
                obj._initProperties(data, false);60
                addToCache(this, id);60
            }
        }
        cb(err, obj);68
    }.bind(this));68
};1
/**
 * Find all instances of Model, matched by query
 * make sure you have marked as `index: true` fields for filter or sort
 *
 * @param {Object} params (optional)
 *
 * - where: Object `{ key: val, key2: {gt: 'val2'}}`
 * - order: String
 * - limit: Number
 * - skip: Number
 *
 * @param {Function} callback (required) called with arguments:
 *
 * - err (null or Error)
 * - Array of instances
 */
AbstractClass.all = function all(params, cb) {
    if (stillConnecting(this.schema, this, arguments)) return;162
    if (arguments.length === 1) {
        cb = params;16
        params = null;16
    }
    var constr = this;162
    this.schema.adapter.all(this.modelName, params, function (err, data) {
        var collection = null;162
        if (data && data.map) {
            collection = data.map(function (d) {
                var obj = null;530
                // do not create different instances for the same object
                var cached = getCached(constr, d.id);530
                if (cached) {
                    obj = cached;
                    // keep dirty attributes untouthed (remove from dataset)
                    substractDirtyAttributes(obj, d);
                    // maybe just obj._initProperties(d);
                    constr.prototype._initProperties.call(obj, d);
                } else {
                    obj = new constr;530
                    obj._initProperties(d, false);530
                    if (obj.id) addToCache(constr, obj);530
                }
                return obj;530
            });162
            cb(err, collection);162
        }
    });162
};1
/**
 * Find one record, same as `all`, limited by 1 and return object, not collection
 * 
 * @param {Object} params - search conditions
 * @param {Function} cb - callback called with (err, instance)
 */
AbstractClass.findOne = function findOne(params, cb) {
    if (stillConnecting(this.schema, this, arguments)) return;24
    if (typeof params === 'function') {
        cb = params;8
        params = {};8
    }
    params.limit = 1;24
    this.all(params, function (err, collection) {
        if (err || !collection || !collection.length > 0) return cb(err);16
        cb(err, collection[0]);16
    });24
};1
function substractDirtyAttributes(object, data) {
    Object.keys(object.toObject()).forEach(function (attr) {
        if (data.hasOwnProperty(attr) && object.propertyChanged(attr)) {
            delete data[attr];
        }
    });
}
/**
 * Destroy all records
 * @param {Function} cb - callback called with (err)
 */
AbstractClass.destroyAll = function destroyAll(cb) {
    if (stillConnecting(this.schema, this, arguments)) return;21
    this.schema.adapter.destroyAll(this.modelName, function (err) {
        clearCache(this);21
        cb(err);21
    }.bind(this));21
};1
/**
 * Return count of matched records
 *
 * @param {Object} where - search conditions (optional)
 * @param {Function} cb - callback, called with (err, count)
 */
AbstractClass.count = function (where, cb) {
    if (stillConnecting(this.schema, this, arguments)) return;24
    if (typeof where === 'function') {
        cb = where;16
        where = null;16
    }
    this.schema.adapter.count(this.modelName, cb, where);24
};1
/**
 * Return string representation of class
 *
 * @override default toString method
 */
AbstractClass.toString = function () {
    return '[Model ' + this.modelName + ']';
}
/**
 * Save instance. When instance haven't id, create method called instead.
 * Triggers: validate, save, update | create
 * @param options {validate: true, throws: false} [optional]
 * @param callback(err, obj)
 */
AbstractClass.prototype.save = function (options, callback) {
    if (stillConnecting(this.constructor.schema, this, arguments)) return;69
    if (typeof options == 'function') {
        callback = options;67
        options = {};67
    }
    callback = callback || function () {};69
    options = options || {};69
    if (!('validate' in options)) {
        options.validate = true;68
    }
    if (!('throws' in options)) {
        options.throws = false;68
    }
    if (options.validate) {
        this.isValid(function (valid) {
            if (valid) {
                save.call(this);67
            } else {
                var err = new Error('Validation error');1
                // throws option is dangerous for async usage
                if (options.throws) {
                    throw err;1
                }
                callback(err, this);
            }
        }.bind(this));67
    } else {
        save.call(this);1
    }
    function save() {
        this.trigger('save', function (saveDone) {
            var modelName = this.constructor.modelName;68
            var data = this.toObject(true);68
            var inst = this;68
            if (inst.id) {
                inst.trigger('update', function (updateDone) {
                    inst._adapter().save(modelName, data, function (err) {
                        if (err) {
                            console.log(err);
                        } else {
                            inst._initProperties(data, false);24
                        }
                        updateDone.call(inst, function () {
                            saveDone.call(inst, function () {
                                callback(err, inst);24
                            });24
                        });24
                    });24
                }, data);24
            } else {
                inst.constructor.create(inst, function (err) {
                    saveDone.call(inst, function () {
                        callback(err, inst);44
                    });44
                });44
            }
        });68
    }
};1
AbstractClass.prototype.isNewRecord = function () {
    return !this.id;28
};1
/**
 * Return adapter of current record
 * @private
 */
AbstractClass.prototype._adapter = function () {
    return this.constructor.schema.adapter;341
};1
/**
 * Convert instance to Object
 *
 * @param {Boolean} onlySchema - restrict properties to schema only, default false
 * when onlySchema == true, only properties defined in schema returned, 
 * otherwise all enumerable properties returned
 * @returns {Object} - canonical object representation (no getters and setters)
 */
AbstractClass.prototype.toObject = function (onlySchema) {
    var data = {};406
    var ds = this.constructor.schema.definitions[this.constructor.modelName];406
    var properties = ds.properties;406
    // weird
    Object.keys(onlySchema ? properties : this).concat(['id']).forEach(function (property) {
        data[property] = this[property];2767
    }.bind(this));406
    return data;406
};1
/**
 * Delete object from persistence
 *
 * @triggers `destroy` hook (async) before and after destroying object
 */
AbstractClass.prototype.destroy = function (cb) {
    if (stillConnecting(this.constructor.schema, this, arguments)) return;10
    this.trigger('destroy', function (destroyed) {
        this._adapter().destroy(this.constructor.modelName, this.id, function (err) {
            removeFromCache(this.constructor, this.id);9
            destroyed(function () {
                cb && cb(err);8
            });9
        }.bind(this));9
    });10
};1
/**
 * Update single attribute
 *
 * equals to `updateAttributes({name: value}, cb)
 *
 * @param {String} name - name of property
 * @param {Mixed} value - value of property
 * @param {Function} callback - callback called with (err, instance)
 */
AbstractClass.prototype.updateAttribute = function updateAttribute(name, value, callback) {
    var data = {};8
    data[name] = value;8
    this.updateAttributes(data, callback);8
};1
/**
 * Update set of attributes
 *
 * this method performs validation before updating
 *
 * @trigger `validation`, `save` and `update` hooks
 * @param {Object} data - data to update
 * @param {Function} callback - callback called with (err, instance)
 */
AbstractClass.prototype.updateAttributes = function updateAttributes(data, cb) {
    if (stillConnecting(this.constructor.schema, this, arguments)) return;20
    var inst = this;20
    var model = this.constructor.modelName;20
    // update instance's properties
    Object.keys(data).forEach(function (key) {
        inst[key] = data[key];29
    });20
    inst.isValid(function (valid) {
        if (!valid) {
            if (cb) {
                cb(new Error('Validation error'));1
            }
        } else {
            update();19
        }
    });20
    function update() {
        inst.trigger('save', function (saveDone) {
            inst.trigger('update', function (done) {
                Object.keys(data).forEach(function (key) {
                    data[key] = inst[key];27
                });18
                inst._adapter().updateAttributes(model, inst.id, data, function (err) {
                    if (!err) {
                        inst._initProperties(data, false);18
                        /*
                        Object.keys(data).forEach(function (key) {
                            inst[key] = data[key];
                            Object.defineProperty(inst, key + '_was', {
                                writable:     false,
                                configurable: true,
                                enumerable:   false,
                                value:        data[key]
                            });
                        });
                        */
                    }
                    done.call(inst, function () {
                        saveDone.call(inst, function () {
                            cb(err, inst);17
                        });17
                    });18
                });18
            }, data);19
        });19
    }
};1
AbstractClass.prototype.fromObject = function (obj) {
    Object.keys(obj).forEach(function (key) {
        this[key] = obj[key];
    }.bind(this));
};1
/**
 * Checks is property changed based on current property and initial value
 *
 * @param {String} attr - property name
 * @return Boolean
 */
AbstractClass.prototype.propertyChanged = function propertyChanged(attr) {
    return this['_' + attr] !== this[attr + '_was'];89
};1
/**
 * Reload object from persistence
 *
 * @requires `id` member of `object` to be able to call `find`
 * @param {Function} callback - called with (err, instance) arguments
 */
AbstractClass.prototype.reload = function reload(callback) {
    if (stillConnecting(this.constructor.schema, this, arguments)) return;16
    var obj = getCached(this.constructor, this.id);16
    if (obj) obj.reset();16
    this.constructor.find(this.id, callback);16
};1
/**
 * Reset dirty attributes
 *
 * this method does not perform any database operation it just reset object to it's
 * initial state
 */
AbstractClass.prototype.reset = function () {
    var obj = this;
    Object.keys(obj).forEach(function (k) {
        if (k !== 'id' && !obj.constructor.schema.definitions[obj.constructor.modelName].properties[k]) {
            delete obj[k];
        }
        if (obj.propertyChanged(k)) {
            obj[k] = obj[k + '_was'];
        }
    });
};1
/**
 * Declare hasMany relation
 *
 * @param {Class} anotherClass - class to has many
 * @param {Object} params - configuration {as:, foreignKey:}
 * @example `User.hasMany(Post, {as: 'posts', foreignKey: 'authorId'});`
 */
AbstractClass.hasMany = function hasMany(anotherClass, params) {
    var methodName = params.as; // or pluralize(anotherClass.modelName)
    var fk = params.foreignKey;8
    // each instance of this class should have method named
    // pluralize(anotherClass.modelName)
    // which is actually just anotherClass.all({where: {thisModelNameId: this.id}}, cb);
    defineScope(this.prototype, anotherClass, methodName, function () {
        var x = {};64
        x[fk] = this.id;64
        return {where: x};64
    }, {
        find: find,
        destroy: destroy
    });8
    // obviously, anotherClass should have attribute called `fk`
    anotherClass.schema.defineForeignKey(anotherClass.modelName, fk);8
    function find(id, cb) {
        anotherClass.find(id, function (err, inst) {
            if (err) return cb(err);
            if (!inst) return cb(new Error('Not found'));
            if (inst[fk] == this.id) {
                cb(null, inst);
            } else {
                cb(new Error('Permission denied'));
            }
        }.bind(this));
    }
    function destroy(id, cb) {
        this.find(id, function (err, inst) {
            if (err) return cb(err);
            if (inst) {
                inst.destroy(cb);
            } else {
                cb(new Error('Not found'));
            }
        });
    }
};1
/**
 * Declare belongsTo relation
 *
 * @param {Class} anotherClass - class to belong
 * @param {Object} params - configuration {as: 'propertyName', foreignKey: 'keyName'}
 */
AbstractClass.belongsTo = function (anotherClass, params) {
    var methodName = params.as;16
    var fk = params.foreignKey;16
    this.schema.defineForeignKey(this.modelName, fk);16
    this.prototype['__finders__'] = this.prototype['__finders__'] || {}
    this.prototype['__finders__'][methodName] = function (id, cb) {
        anotherClass.find(id, function (err,inst) {
            if (err) return cb(err);
            if (inst[fk] === this.id) {
                cb(null, inst);
            } else {
                cb(new Error('Permission denied'));
            }
        }.bind(this));
    }
    this.prototype[methodName] = function (p) {
        if (p instanceof AbstractClass) { // acts as setter
            this[fk] = p.id;
            this.cachedRelations[methodName] = p;
        } else if (typeof p === 'function') { // acts as async getter
            this.__finders__[methodName](this[fk], p);
            return this[fk];
        } else if (typeof p === 'undefined') { // acts as sync getter
            return this[fk];16
        } else { // setter
            this[fk] = p;8
        }
    };16
};1
/**
 * Define scope
 * TODO: describe behavior and usage examples
 */
AbstractClass.scope = function (name, params) {
    defineScope(this, this, name, params);8
};1
function defineScope(cls, targetClass, name, params, methods) {
    // collect meta info about scope
    if (!cls._scopeMeta) {
        cls._scopeMeta = {};8
    }
    // anly make sence to add scope in meta if base and target classes
    // are same
    if (cls === targetClass) {
        cls._scopeMeta[name] = params;8
    } else {
        if (!targetClass._scopeMeta) {
            targetClass._scopeMeta = {};8
        }
    }
    Object.defineProperty(cls, name, {
        enumerable: false,
        configurable: true,
        get: function () {
            var f = function caller(cond, cb) {
                var actualCond;8
                if (arguments.length === 1) {
                    actualCond = {};8
                    cb = cond;8
                } else if (arguments.length === 2) {
                    actualCond = cond;
                } else {
                    throw new Error('Method only can be called with one or two arguments');
                }
                return targetClass.all(mergeParams(actualCond, caller._scope), cb);8
            };96
            f._scope = typeof params === 'function' ? params.call(this) : params;96
            f.build = build;96
            f.create = create;96
            f.destroyAll = destroyAll;96
            for (var i in methods) {
                f[i] = methods[i].bind(this);128
            }
            // define sub-scopes
            Object.keys(targetClass._scopeMeta).forEach(function (name) {
                Object.defineProperty(f, name, {
                    enumerable: false,
                    get: function () {
                        mergeParams(f._scope, targetClass._scopeMeta[name]);24
                        return f;24
                    }
                });56
            }.bind(this));96
            return f;96
        }
    });16
    // and it should have create/build methods with binded thisModelNameId param
    function build(data) {
        data = data || {};24
        return new targetClass(mergeParams(this._scope, {where:data}).where);24
    }
    function create(data, cb) {
        if (typeof data === 'function') {
            cb = data;16
            data = {};16
        }
        this.build(data).save(cb);16
    }
    function destroyAll(id, cb) {
        // implement me
    }
    function mergeParams(base, update) {
        if (update.where) {
            base.where = merge(base.where, update.where);56
        }
        // overwrite order
        if (update.order) {
            base.order = update.order;
        }
        return base;56
    }
}
/**
 * Check whether `s` is not undefined
 * @param {Mixed} s
 * @return {Boolean} s is undefined
 */
function isdef(s) {
    var undef;19675
    return s !== undef;19675
}
/**
 * Merge `base` and `update` params
 * @param {Object} base - base object (updating this object)
 * @param {Object} update - object with new data to update base
 * @returns {Object} `base`
 */
function merge(base, update) {
    base = base || {};56
    if (update) {
        Object.keys(update).forEach(function (key) {
            base[key] = update[key];32
        });56
    }
    return base;56
}
/**
 * Define readonly property on object
 *
 * @param {Object} obj
 * @param {String} key
 * @param {Mixed} value
 */
function defineReadonlyProp(obj, key, value) {
    Object.defineProperty(obj, key, {
        writable: false,
        enumerable: true,
        configurable: true,
        value: value
    });949
}
/**
 * Add object to cache
 */
function addToCache(constr, obj) {
    return;892
    touchCache(constr, obj.id);
    constr.cache[obj.id] = obj;
}
/**
 * Renew object position in LRU cache index
 */
function touchCache(constr, id) {
    var cacheLimit = constr.CACHE_LIMIT || DEFAULT_CACHE_LIMIT;600
    var ind = constr.mru.indexOf(id);600
    if (~ind) constr.mru.splice(ind, 1);600
    if (constr.mru.length >= cacheLimit * 2) {
        for (var i = 0; i < cacheLimit;i += 1) {
            delete constr.cache[constr.mru[i]];
        }
        constr.mru.splice(0, cacheLimit);
    }
}
/**
 * Retrieve cached object
 */
function getCached(constr, id) {
    if (id) touchCache(constr, id);606
    return id && constr.cache[id];606
}
/**
 * Clear cache (fully)
 *
 * removes both cache and LRU index
 *
 * @param {Class} constr - class constructor
 */
function clearCache(constr) {
    constr.cache = {};21
    constr.mru = [];21
}
/**
 * Remove object from cache
 *
 * @param {Class} constr
 * @param {id} id
 */
function removeFromCache(constr, id) {
    var ind = constr.mru.indexOf(id);9
    if (!~ind) constr.mru.splice(ind, 1);9
    delete constr.cache[id];9
}

var safeRequire = require('../utils').safeRequire;
/**
 * Module dependencies
 */
var redis = safeRequire('redis');1
exports.initialize = function initializeSchema(schema, callback) {
    if (!redis) return;1
    if (schema.settings.url) {
        var url = require('url');
        var redisUrl = url.parse(schema.settings.url);
        var redisAuth = (redisUrl.auth || '').split(':');
        schema.settings.host = redisUrl.hostname;
        schema.settings.port = redisUrl.port;
        if (redisAuth.length == 2) {
            schema.settings.db = redisAuth[0];
            schema.settings.password = redisAuth[1];
        }
    }
    schema.client = redis.createClient(
        schema.settings.port,
        schema.settings.host,
        schema.settings.options
    );1
    schema.client.auth(schema.settings.password);1
    schema.client.on('connect', callback);1
    schema.adapter = new BridgeToRedis(schema.client);1
};1
function BridgeToRedis(client) {
    this._models = {};1
    this.client = client;1
    this.indexes = {};1
}
BridgeToRedis.prototype.define = function (descr) {
    var m = descr.model.modelName;3
    this._models[m] = descr;3
    this.indexes[m] = {};3
    Object.keys(descr.properties).forEach(function (prop) {
        if (descr.properties[prop].index) {
            this.indexes[m][prop] = descr.properties[prop].type;4
        }
    }.bind(this));3
};1
BridgeToRedis.prototype.defineForeignKey = function (model, key, cb) {
    this.indexes[model][key] = Number;2
    cb(null, Number);2
};1
BridgeToRedis.prototype.save = function (model, data, callback) {
    deleteNulls(data);34
    var log = this.logger('HMSET ' + model + ':' + data.id + ' ...');34
    this.client.hmset(model + ':' + data.id, data, function (err) {
        log();34
        if (err) return callback(err);34
        this.updateIndexes(model, data.id, data, callback);34
    }.bind(this));34
};1
BridgeToRedis.prototype.updateIndexes = function (model, id, data, callback) {
    var i = this.indexes[model];36
    var schedule = [['sadd', 's:' + model, id]];36
    Object.keys(data).forEach(function (key) {
        if (i[key]) {
            schedule.push([
                'sadd',
                'i:' + model + ':' + key + ':' + data[key],
                model + ':' + id
            ]);56
        }
    }.bind(this));36
    if (schedule.length) {
        this.client.multi(schedule).exec(function (err) {
            callback(err, data);36
        });36
    } else {
        callback(null);
    }
};1
BridgeToRedis.prototype.create = function (model, data, callback) {
    if (data.id) return create.call(this, data.id, true);29
    var log = this.logger('INCR id:' + model);29
    this.client.incr('id:' + model, function (err, id) {
        log();29
        create.call(this, id);29
    }.bind(this));29
    function create(id, upsert) {
        data.id = id;29
        this.save(model, data, function (err) {
            if (callback) {
                callback(err, id);29
            }
        });29
        // push the id to the list of user ids for sorting
        log('SADD s:' + model + ' ' + data.id);29
        this.client.sadd("s:" + model, upsert ? data : data.id);29
    }
};1
BridgeToRedis.prototype.updateOrCreate = function (model, data, callback) {
    if (!data.id) return this.create(model, data, callback);2
    this.save(model, data, callback);2
};1
BridgeToRedis.prototype.exists = function (model, id, callback) {
    var log = this.logger('EXISTS ' + model + ':' + id);3
    this.client.exists(model + ':' + id, function (err, exists) {
        log();3
        if (callback) {
            callback(err, exists);3
        }
    });3
};1
BridgeToRedis.prototype.find = function find(model, id, callback) {
    var t1 = Date.now();9
    this.client.hgetall(model + ':' + id, function (err, data) {
        this.log('HGETALL ' + model + ':' + id, t1);9
        if (data && Object.keys(data).length > 0) {
            data.id = id;8
        } else {
            data = null;1
        }
        callback(err, data);9
    }.bind(this));9
};1
BridgeToRedis.prototype.destroy = function destroy(model, id, callback) {
    var t1 = Date.now();1
    this.client.del(model + ':' + id, function (err) {
        this.log('DEL ' + model + ':' + id, t1);1
        callback(err);1
    }.bind(this));1
    this.log('SREM s:' + model, t1);1
    this.client.srem("s:" + model, id);1
};1
BridgeToRedis.prototype.possibleIndexes = function (model, filter) {
    if (!filter || Object.keys(filter.where || {}).length === 0) return false;13
    var foundIndex = [];13
    var noIndex = [];13
    Object.keys(filter.where).forEach(function (key) {
        if (this.indexes[model][key] && (typeof filter.where[key] === 'string' || typeof filter.where[key] === 'number')) {
            foundIndex.push('i:' + model + ':' + key + ':' + filter.where[key]);10
        } else {
            noIndex.push(key);3
        }
    }.bind(this));13
    return [foundIndex, noIndex];13
};1
BridgeToRedis.prototype.all = function all(model, filter, callback) {
    var ts = Date.now();18
    var client = this.client;18
    var log = this.log;18
    var t1 = Date.now();18
    var cmd;18
    var that = this;18
    var sortCmd = [];18
    var props = this._models[model].properties;18
    var allNumeric = true;18
    // TODO: we need strict mode when filtration only possible when we have indexes
    // WHERE
    if (filter && filter.where) {
        var pi = this.possibleIndexes(model, filter);13
        var indexes = pi[0];13
        var noIndexes = pi[1];13
        if (indexes && indexes.length) {
            cmd = 'SINTER "' + indexes.join('" "') + '"';10
            if (noIndexes.length) {
                log(model + ': no indexes found for ', noIndexes.join(', '),
                    'slow sorting and filtering');
            }
            indexes.push(noIndexes.length ? orderLimitStageBad : orderLimitStage);10
            client.sinter.apply(client, indexes);10
        } else {
            // filter manually
            cmd = 'KEYS ' + model + ':*';3
            client.keys(model + ':*', orderLimitStageBad);3
        }
    } else {
        // no filtering, just sort/limit (if any)
        gotKeys('*');5
    }
    // bad case when we trying to filter on non-indexed fields
    // in bad case we need retrieve all data and filter/limit/sort manually
    function orderLimitStageBad(err, keys) {
        log(cmd, t1);3
        var t2 = Date.now();3
        if (err) {
            return callback(err, []);
        }
        var query = keys.map(function (key) {
            return ['hgetall', key];40
        });3
        client.multi(query).exec(function (err, replies) {
            log(query, t2);3
            gotFilteredData(err, replies.filter(applyFilter(filter)));3
        });3
        function gotFilteredData(err, nodes) {
            if (err) return callback(null);3
            if (filter.order) {
                var allNumeric = true;
                var orders = filter.order;
                if (typeof filter.order === "string") {
                    orders = [filter.order];
                }
                orders.forEach(function (key) {
                    key = key.split(' ')[0];
                    if (props[key].type.name !== 'Number' && props[key].type.name !== 'Date') {
                        allNumeric = false;
                    }
                });
                if (allNumeric) {
                    nodes = nodes.sort(numerically.bind(orders));
                } else {
                    nodes = nodes.sort(literally.bind(orders));
                }
            }
            // LIMIT
            if (filter && filter.limit) {
                var from = (filter.offset || 0), to = from + filter.limit;
                callback(null, nodes.slice(from, to));
            } else {
                callback(null, nodes);3
            }
        }
    }
    function orderLimitStage(err, keys) {
        log(cmd, t1);10
        var t2 = Date.now();10
        if (err) {
            return callback(err, []);
        }
        gotKeys(keys);10
    }
    function gotKeys(keys) {
        // ORDER
        var reverse = false;15
        if (filter && filter.order) {
            var orders = filter.order;6
            if (typeof filter.order === "string"){
                orders = [filter.order];6
            }
            orders.forEach(function (key) {
                var m = key.match(/\s+(A|DE)SC$/i);6
                if (m) {
                    key = key.replace(/\s+(A|DE)SC/i, '');3
                    if (m[1] === 'DE') reverse = true;3
                }
                if (key !== 'id') {
                    if (props[key].type.name !== 'Number' && props[key].type.name !== 'Date') {
                        allNumeric = false;5
                    }
                }
                sortCmd.push("BY", model + ":*->" + key);6
            });6
        }
        // LIMIT
        if (keys === '*' && filter && filter.limit){
            var from = (filter.offset || 0), to = from + filter.limit;1
            sortCmd.push("LIMIT", from, to);1
        }
        // we need ALPHA modifier when sorting string values
        // the only case it's not required - we sort numbers
        // TODO: check if we sort numbers
        if (!allNumeric) {
            sortCmd.push('ALPHA');5
        }
        if (reverse) {
            sortCmd.push('DESC');2
        }
        if (sortCmd.length) {
            sortCmd.unshift("s:" + model);7
            sortCmd.push("GET", "#");7
            cmd = "SORT " + sortCmd.join(" ");7
            var ttt = Date.now();7
            sortCmd.push(function(err, ids){
                if (err) {
                    return callback(err, []);
                }
                log(cmd, ttt);7
                var sortedKeys = ids.map(function (i) {
                    return model + ":" + i;35
                });7
                handleKeys(err, intersect(sortedKeys, keys));7
            });7
            client.sort.apply(client, sortCmd);7
        } else {
            // no sorting or filtering: just get all keys
            if (keys === '*') {
                cmd = 'KEYS ' + model + ':*';2
                client.keys(model + ':*', handleKeys);2
            } else {
                handleKeys(null, keys);6
            }
        }
    }
    function handleKeys(err, keys) {
        var t2 = Date.now();15
        var query = keys.map(function (key) {
            return ['hgetall', key];96
        });15
        client.multi(query).exec(function (err, replies) {
            log(query, t2);15
            // console.log('Redis time: %dms', Date.now() - ts);
            callback(err, filter ? replies.filter(applyFilter(filter)) : replies);15
        });15
    }
    return;18
    function numerically(a, b) {
        return a[this[0]] - b[this[0]];
    }
    function literally(a, b) {
        return a[this[0]] > b[this[0]];
    }
    // TODO: find better intersection method
    function intersect(sortedKeys, filteredKeys) {
        if (filteredKeys === '*') return sortedKeys;4
        var index = {};4
        filteredKeys.forEach(function (x) {
            index[x] = true;288
        });4
        return sortedKeys.filter(function (x) {4
            return index[x];24
        });
    }
};1
function applyFilter(filter) {
    if (typeof filter.where === 'function') {
        return filter.where;
    }
    var keys = Object.keys(filter.where || {});16
    return function (obj) {16
        var pass = true;120
        keys.forEach(function (key) {
            if (!test(filter.where[key], obj[key])) {
                pass = false;84
            }
        });120
        return pass;120
    };
    function test(example, value) {
        if (typeof value === 'string' && example && example.constructor.name === 'RegExp') {
            return value.match(example);15
        }
        // not strict equality
        return example == value;94
    }
}
BridgeToRedis.prototype.destroyAll = function destroyAll(model, callback) {
    var keysQuery = model + ':*';2
    var t1 = Date.now();2
    this.client.keys(keysQuery, function (err, keys) {
        this.log('KEYS ' + keysQuery, t1);2
        if (err) {
            return callback(err, []);
        }
        var query = keys.map(function (key) {
            return ['del', key];30
        });2
        var t2 = Date.now();2
        this.client.multi(query).exec(function (err, replies) {
            this.log(query, t2);2
            this.client.del('s:' + model, function () {
                callback(err);2
            });2
        }.bind(this));2
    }.bind(this));2
};1
BridgeToRedis.prototype.count = function count(model, callback, where) {
    var keysQuery = model + ':*';3
    var t1 = Date.now();3
    if (where && Object.keys(where).length) {
        this.all(model, {where: where}, function (err, data) {
            callback(err, err ? null : data.length);1
        });1
    } else {
        this.client.keys(keysQuery, function (err, keys) {
            this.log('KEYS ' + keysQuery, t1);2
            callback(err, err ? null : keys.length);2
        }.bind(this));2
    }
};1
BridgeToRedis.prototype.updateAttributes = function updateAttrs(model, id, data, cb) {
    var t1 = Date.now();2
    deleteNulls(data);2
    this.client.hmset(model + ':' + id, data, function () {
        this.log('HMSET ' + model + ':' + id, t1);2
        this.updateIndexes(model, id, data, cb);2
    }.bind(this));2
};1
function deleteNulls(data) {
    Object.keys(data).forEach(function (key) {
        if (data[key] === null) delete data[key];231
    });36
}
BridgeToRedis.prototype.disconnect = function disconnect() {
    this.log('QUIT', Date.now());1
    this.client.quit();1
};1

var safeRequire = require('../utils').safeRequire;
/**
 * Module dependencies
 */
var mysql = safeRequire('mysql');1
var BaseSQL = require('../sql');1
exports.initialize = function initializeSchema(schema, callback) {
    if (!mysql) return;2
    var s = schema.settings;2
    schema.client = mysql.createClient({
        host: s.host || 'localhost',
        port: s.port || 3306,
        user: s.username,
        password: s.password,
        debug: s.debug
    });2
    schema.adapter = new MySQL(schema.client);2
    schema.adapter.schema = schema;2
    // schema.client.query('SET TIME_ZONE = "+04:00"', callback);
    schema.client.query('USE ' + s.database, function (err) {
        if (err && err.message.match(/^unknown database/i)) {
            var dbName = s.database;
            schema.client.query('CREATE DATABASE ' + dbName, function (error) {
                if (!error) {
                    schema.client.query('USE ' + s.database, callback);
                } else {
                    throw error;
                }
            });
        } else callback();2
    });2
};1
/**
 * MySQL adapter
 */
function MySQL(client) {
    this._models = {};2
    this.client = client;2
}
require('util').inherits(MySQL, BaseSQL);1
MySQL.prototype.query = function (sql, callback) {
    if (!this.schema.connected) {
        return this.schema.on('connected', function () {1
            this.query(sql, callback);1
        }.bind(this));
    }
    var client = this.client;105
    var time = Date.now();105
    var log = this.log;105
    if (typeof callback !== 'function') throw new Error('callback should be a function');105
    this.client.query(sql, function (err, data) {
        if (err && err.message.match(/^unknown database/i)) {
            var dbName = err.message.match(/^unknown database ~~~S11~~~/i)[1];
            client.query('CREATE DATABASE ' + dbName, function (error) {
                if (!error) {
                    client.query(sql, callback);
                } else {
                    callback(err);
                }
            });
            return;
        }
        if (log) log(sql, time);105
        callback(err, data);105
    });105
};1
/**
 * Must invoke callback(err, id)
 */
MySQL.prototype.create = function (model, data, callback) {
    var fields = this.toFields(model, data);39
    var sql = 'INSERT INTO ' + this.tableEscaped(model);39
    if (fields) {
        sql += ' SET ' + fields;39
    } else {
        sql += ' VALUES ()';
    }
    this.query(sql, function (err, info) {
        callback(err, info && info.insertId);39
    });39
};1
MySQL.prototype.updateOrCreate = function (model, data, callback) {
    var mysql = this;2
    var fieldsNames = [];2
    var fieldValues = [];2
    var combined = [];2
    var props = this._models[model].properties;2
    Object.keys(data).forEach(function (key) {
        if (props[key] || key === 'id') {
            var k = '`' + key + '`';12
            var v;12
            if (key !== 'id') {
                v = mysql.toDatabase(props[key], data[key]);10
            } else {
                v = data[key];2
            }
            fieldsNames.push(k);12
            fieldValues.push(v);12
            if (key !== 'id') combined.push(k + ' = ' + v);12
        }
    });2
    var sql = 'INSERT INTO ' + this.tableEscaped(model);2
    sql += ' (' + fieldsNames.join(', ') + ')';2
    sql += ' VALUES (' + fieldValues.join(', ') + ')';2
    sql += ' ON DUPLICATE KEY UPDATE ' + combined.join(', ');2
    this.query(sql, function (err, info) {
        if (!err && info && info.insertId) {
            data.id = info.insertId;2
        }
        callback(err, data);2
    });2
};1
MySQL.prototype.toFields = function (model, data) {
    var fields = [];44
    var props = this._models[model].properties;44
    Object.keys(data).forEach(function (key) {
        if (props[key]) {
            fields.push('`' + key.replace(/\./g, '`.`') + '` = ' + this.toDatabase(props[key], data[key]));239
        }
    }.bind(this));44
    return fields.join(',');44
};1
function dateToMysql(val) {
    return val.getUTCFullYear() + '-' +39
        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;195
    }
}
MySQL.prototype.toDatabase = function (prop, val) {
    if (val === null) return 'NULL';121
    if (val.constructor.name === 'Object') {
        var operator = Object.keys(val)[0]
        val = val[operator];5
        if (operator === 'between') {
            return  this.toDatabase(prop, val[0]) +1
                    ' 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) return val;120
    if (prop.type.name === 'Number') return val;118
    if (prop.type.name === 'Date') {
        if (!val) return 'NULL';39
        if (!val.toUTCString) {
            val = new Date(val);14
        }
        return '"' + dateToMysql(val) + '"';39
    }
    if (prop.type.name == "Boolean") return val ? 1 : 0;47
    return this.client.escape(val.toString());47
};1
MySQL.prototype.fromDatabase = function (model, data) {
    if (!data) return null;74
    var props = this._models[model].properties;74
    Object.keys(data).forEach(function (key) {
        var val = data[key];478
        if (props[key]) {
            if (props[key].type.name === 'Date' && val !== null) {
                val = new Date(val.toString().replace(/GMT.*$/, 'GMT'));57
            }
        }
        data[key] = val;478
    });74
    return data;74
};1
MySQL.prototype.escapeName = function (name) {
    return '`' + name.replace(/\./g, '`.`') + '`';114
};1
MySQL.prototype.all = function all(model, filter, callback) {
    var sql = 'SELECT * FROM ' + this.tableEscaped(model);21
    var self = this;21
    var props = this._models[model].properties;21
    if (filter) {
        if (filter.where) {
            sql += ' ' + buildWhere(filter.where);16
        }
        if (filter.order) {
            sql += ' ' + buildOrderBy(filter.order);6
        }
        if (filter.limit) {
            sql += ' ' + buildLimit(filter.limit, filter.offset || 0);5
        }
    }
    this.query(sql, function (err, data) {
        if (err) {
            return callback(err, []);
        }
        callback(null, data.map(function (obj) {
            return self.fromDatabase(model, obj);66
        }));21
    }.bind(this));21
    return sql;21
    function buildWhere(conds) {
        var cs = [];16
        Object.keys(conds).forEach(function (key) {
            var keyEscaped = '`' + key.replace(/\./g, '`.`') + '`'
            var val = self.toDatabase(props[key], conds[key]);16
            if (conds[key] === null) {
                cs.push(keyEscaped + ' IS NULL');1
            } else if (conds[key].constructor.name === 'Object') {
                var condType = Object.keys(conds[key])[0];5
                var sqlCond = keyEscaped;5
                switch (condType) {
                    case 'gt':
                        sqlCond += ' > ';1
                        break;1
                    case 'gte':
                        sqlCond += ' >= ';1
                        break;1
                    case 'lt':
                        sqlCond += ' < ';1
                        break;1
                    case 'lte':
                        sqlCond += ' <= ';1
                        break;1
                    case 'between':
                        sqlCond += ' BETWEEN ';1
                        break;1
                    case 'inq':
                        sqlCond += ' IN ';
                        break;
                    case 'nin':
                        sqlCond += ' NOT IN ';
                        break;
                    case 'neq':
                        sqlCond + ' != ';
                        break;
                }
                sqlCond += (condType == 'inq' || condType == 'nin') ? '(' + val + ')' : val;5
                cs.push(sqlCond);5
            } else {
                cs.push(keyEscaped + ' = ' + val);10
            }
        });16
        if (cs.length === 0) {
          return '';
        }
        return 'WHERE ' + cs.join(' AND ');16
    }
    function buildOrderBy(order) {
        if (typeof order === 'string') order = [order];6
        return 'ORDER BY ' + order.join(', ');6
    }
    function buildLimit(limit, offset) {
        return 'LIMIT ' + (offset ? (offset + ', ' + limit) : limit);5
    }
};1
MySQL.prototype.autoupdate = function (cb) {
    var self = this;1
    var wait = 0;1
    Object.keys(this._models).forEach(function (model) {
        wait += 1;1
        self.query('SHOW FIELDS FROM ' + self.tableEscaped(model), function (err, fields) {
            if (!err && fields.length) {
                self.alterTable(model, fields, done);1
            } else {
                self.createTable(model, done);
            }
        });1
    });1
    function done(err) {
        if (err) {
            console.log(err);
        }
        if (--wait === 0 && cb) {
            cb();1
        }
    }
};1
MySQL.prototype.isActual = function (cb) {
    var ok = false;2
    var self = this;2
    var wait = 0;2
    Object.keys(this._models).forEach(function (model) {
        wait += 1;2
        self.query('SHOW FIELDS FROM ' + model, function (err, fields) {
            self.alterTable(model, fields, done, true);2
        });2
    });2
    function done(err, needAlter) {
        if (err) {
            console.log(err);
        }
        ok = ok || needAlter;2
        if (--wait === 0 && cb) {
            cb(null, !ok);2
        }
    }
};1
MySQL.prototype.alterTable = function (model, actualFields, done, checkOnly) {
    var self = this;3
    var m = this._models[model];3
    var propNames = Object.keys(m.properties).filter(function (name) {
        return !!m.properties[name];24
    });3
    var sql = [];3
    // change/add new fields
    propNames.forEach(function (propName) {
        var found;20
        actualFields.forEach(function (f) {
            if (f.Field === propName) {
                found = f;19
            }
        });20
        if (found) {
            actualize(propName, found);19
        } else {
            sql.push('ADD COLUMN `' + propName + '` ' + self.propertySettingsSQL(model, propName));1
        }
    });3
    // drop columns
    actualFields.forEach(function (f) {
        var notFound = !~propNames.indexOf(f.Field);24
        if (f.Field === 'id') return;21
        if (notFound || !m.properties[f.Field]) {
            sql.push('DROP COLUMN `' + f.Field + '`');2
        }
    });3
    if (sql.length) {
        if (checkOnly) {
            done(null, true);1
        } else {
            this.query('ALTER TABLE `' + model + '` ' + sql.join(',\n'), done);1
        }
    } else {
        done();1
    }
    function actualize(propName, oldSettings) {
        var newSettings = m.properties[propName];19
        if (newSettings && changed(newSettings, oldSettings)) {
            sql.push('CHANGE COLUMN `' + propName + '` `' + propName + '` ' + self.propertySettingsSQL(model, propName));2
        }
    }
    function changed(newSettings, oldSettings) {
        if (oldSettings.Null === 'YES' && (newSettings.allowNull === false || newSettings.null === false)) return true;19
        if (oldSettings.Null === 'NO' && !(newSettings.allowNull === false || newSettings.null === false)) return true;18
        if (oldSettings.Type.toUpperCase() !== datatype(newSettings)) return true;17
        return false;17
    }
};1
MySQL.prototype.propertiesSQL = function (model) {
    var self = this;4
    var sql = ['`id` INT(11) NOT NULL AUTO_INCREMENT UNIQUE PRIMARY KEY'];4
    Object.keys(this._models[model].properties).forEach(function (prop) {
        sql.push('`' + prop + '` ' + self.propertySettingsSQL(model, prop));21
    });4
    return sql.join(',\n  ');4
};1
MySQL.prototype.propertySettingsSQL = function (model, prop) {
    var p = this._models[model].properties[prop];24
    return datatype(p) + ' ' +24
    (p.allowNull === false || p['null'] === false ? 'NOT NULL' : 'NULL');
};1
function datatype(p) {
    var dt = '';42
    switch (p.type.name) {
        case 'String':
        dt = 'VARCHAR(' + (p.limit || 255) + ')';17
        break;17
        case 'Text':
        dt = 'TEXT';6
        break;6
        case 'Number':
        dt = 'INT(' + (p.limit || 11) + ')';7
        break;7
        case 'Date':
        dt = 'DATETIME';6
        break;6
        case 'Boolean':
        dt = 'TINYINT(1)';6
        break;6
    }
    return dt;42
}

var safeRequire = require('../utils').safeRequire;
/**
 * Module dependencies
 */
var sqlite3 = safeRequire('sqlite3');1
var BaseSQL = require('../sql');1
exports.initialize = function initializeSchema(schema, callback) {
    if (!sqlite3) return;1
    var s = schema.settings;1
    var Database = sqlite3.verbose().Database;1
    var db = new Database(s.database);1
    schema.client = db;1
    schema.adapter = new SQLite3(schema.client);1
    if (s.database === ':memory:') {
        schema.adapter.automigrate(callback);1
    } else {
        process.nextTick(callback);
    }
};1
function SQLite3(client) {
    this._models = {};1
    this.client = client;1
}
require('util').inherits(SQLite3, BaseSQL);1
SQLite3.prototype.command = function () {
    this.query('run', [].slice.call(arguments));55
};1
SQLite3.prototype.queryAll = function () {
    this.query('all', [].slice.call(arguments));21
};1
SQLite3.prototype.queryOne = function () {
    this.query('get', [].slice.call(arguments));15
};1
SQLite3.prototype.query = function (method, args) {
    var time = Date.now();91
    var log = this.log;91
    var cb = args.pop();91
    if (typeof cb === 'function') {
        args.push(function (err, data) {
            if (log) log(args[0], time);91
            cb.call(this, err, data);91
        });91
    } else {
        args.push(cb);
        args.push(function (err, data) {
            log(args[0], time);
        });
    }
    this.client[method].apply(this.client, args);91
};1
SQLite3.prototype.save = function (model, data, callback) {
    var queryParams = [];5
    var sql = 'UPDATE ' + this.tableEscaped(model) + ' SET ' +
    Object.keys(data).map(function (key) {
        queryParams.push(data[key]);23
        return key + ' = ?';23
    }).join(', ') + ' WHERE id = ' + data.id;5
    this.command(sql, queryParams, function (err) {
        callback(err);5
    });5
};1
/**
 * Must invoke callback(err, id)
 */
SQLite3.prototype.create = function (model, data, callback) {
    data = data || {};38
    var questions = [];38
    var values = Object.keys(data).map(function (key) {
        questions.push('?');252
        return data[key];252
    });38
    var sql = 'INSERT INTO ' + this.tableEscaped(model) + ' (' + Object.keys(data).join(',') + ') VALUES ('
    sql += questions.join(',');38
    sql += ')';38
    this.command(sql, values, function (err) {
        callback(err, this && this.lastID);38
    });38
};1
SQLite3.prototype.updateOrCreate = function (model, data, callback) {
    data = data || {};2
    var questions = [];2
    var values = Object.keys(data).map(function (key) {
        questions.push('?');12
        return data[key];12
    });2
    var sql = 'INSERT OR REPLACE INTO ' + this.tableEscaped(model) + ' (' + Object.keys(data).join(',') + ') VALUES ('
    sql += questions.join(',');2
    sql += ')';2
    this.command(sql, values, function (err) {
        if (!err && this) {
            data.id = this.lastID;2
        }
        callback(err, data);2
    });2
};1
SQLite3.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(',');
};1
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;
    }
}
SQLite3.prototype.toDatabase = function (prop, val) {
    if (!prop) return val;11
    if (prop.type.name === 'Number') return val;10
    if (val === null) return 'NULL';10
    if (prop.type.name === 'Date') {
        if (!val) return 'NULL';2
        if (!val.toUTCString) {
            val = new Date(val);
        }
        return val;2
    }
    if (prop.type.name == "Boolean") return val ? 1 : 0;8
    return val.toString();8
};1
SQLite3.prototype.fromDatabase = function (model, data) {
    if (!data) return null;74
    var props = this._models[model].properties;74
    Object.keys(data).forEach(function (key) {
        var val = data[key];478
        if (props[key]) {
            if (props[key].type.name === 'Date') {
                val = new Date(parseInt(val));74
            }
        }
        data[key] = val;478
    });74
    return data;74
};1
SQLite3.prototype.escapeName = function (name) {
    return '`' + name + '`';92
};1
SQLite3.prototype.exists = function (model, id, callback) {
    var sql = 'SELECT 1 FROM ' + this.tableEscaped(model) + ' WHERE id = ' + id + ' LIMIT 1';3
    this.queryOne(sql, function (err, data) {
        if (err) return callback(err);3
        callback(null, data && data['1'] === 1);3
    });3
};1
SQLite3.prototype.find = function find(model, id, callback) {
    var sql = 'SELECT * FROM ' + this.tableEscaped(model) + ' WHERE id = ' + id + ' LIMIT 1';9
    this.queryOne(sql, function (err, data) {
        if (data) {
            data.id = id;8
        } else {
            data = null;1
        }
        callback(err, this.fromDatabase(model, data));9
    }.bind(this));9
};1
SQLite3.prototype.all = function all(model, filter, callback) {
    var sql = 'SELECT * FROM ' + this.tableEscaped(model);21
    var self = this;21
    var props = this._models[model].properties;21
    var queryParams = [];21
    if (filter) {
        if (filter.where) {
            sql += ' ' + buildWhere(filter.where);16
        }
        if (filter.order) {
            sql += ' ' + buildOrderBy(filter.order);6
        }
        if (filter.limit) {
            sql += ' ' + buildLimit(filter.limit, filter.offset || 0);5
        }
    }
    this.queryAll(sql, queryParams, function (err, data) {
        if (err) {
            return callback(err, []);
        }
        callback(null, data.map(function (obj) {
            return self.fromDatabase(model, obj);66
        }));21
    }.bind(this));21
    return sql;21
    function buildWhere(conds) {
        var cs = [];16
        Object.keys(conds).forEach(function (key) {
            var keyEscaped = '`' + key.replace(/\./g, '`.`') + '`'
            if (conds[key] === null) {
                cs.push(keyEscaped + ' IS NULL');1
            } else if (conds[key].constructor.name === 'Object') {
                var condType = Object.keys(conds[key])[0];5
                var sqlCond = keyEscaped;5
                switch (condType) {
                    case 'gt':
                    sqlCond += ' > ';1
                    break;1
                    case 'gte':
                    sqlCond += ' >= ';1
                    break;1
                    case 'lt':
                    sqlCond += ' < ';1
                    break;1
                    case 'lte':
                    sqlCond += ' <= ';1
                    break;1
                    case 'between':
                    sqlCond += ' BETWEEN ? AND ?';1
                    queryParams.push(conds[key][condType][0]);1
                    queryParams.push(conds[key][condType][1]);1
                    break;1
                }
                if (condType !== 'between') {
                    sqlCond += '?';4
                    queryParams.push(conds[key][condType]);4
                }
                cs.push(sqlCond);5
            } else {
                cs.push(keyEscaped + ' = ?');10
                queryParams.push(self.toDatabase(props[key], conds[key]));10
            }
        });16
        return 'WHERE ' + cs.join(' AND ');16
    }
    function buildOrderBy(order) {
        if (typeof order === 'string') order = [order];6
        return 'ORDER BY ' + order.join(', ');6
    }
    function buildLimit(limit, offset) {
        return 'LIMIT ' + (offset ? (offset + ', ' + limit) : limit);5
    }
};1
SQLite3.prototype.count = function count(model, callback, where) {
    var self = this;3
    var props = this._models[model].properties;3
    var queryParams = [];3
    this.queryOne('SELECT count(*) as cnt FROM ' +
        this.tableEscaped(model) + ' ' + buildWhere(where), queryParams, function (err, res) {
        if (err) return callback(err);3
        callback(err, err ? null : res.cnt);3
    });3
    function buildWhere(conds) {
        var cs = [];3
        Object.keys(conds || {}).forEach(function (key) {
            var keyEscaped = '`' + key.replace(/\./g, '`.`') + '`'
            if (conds[key] === null) {
                cs.push(keyEscaped + ' IS NULL');
            } else {
                cs.push(keyEscaped + ' = ?');1
                queryParams.push(self.toDatabase(props[key], conds[key]));1
            }
        });3
        return cs.length ? ' WHERE ' + cs.join(' AND ') : '';3
    }
};1
SQLite3.prototype.disconnect = function disconnect() {
    this.client.close();1
};1
SQLite3.prototype.autoupdate = function (cb) {
    var self = this;
    var wait = 0;
    Object.keys(this._models).forEach(function (model) {
        wait += 1;
        self.queryAll('SHOW FIELDS FROM ' + this.tableEscaped(model), function (err, fields) {
            self.alterTable(model, fields, done);
        });
    });
    function done(err) {
        if (err) {
            console.log(err);
        }
        if (--wait === 0 && cb) {
            cb();
        }
    }
};1
SQLite3.prototype.alterTable = function (model, actualFields, done) {
    var self = this;
    var m = this._models[model];
    var propNames = Object.keys(m.properties);
    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) {
        this.command('ALTER TABLE ' + this.tableEscaped(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;
    }
};1
SQLite3.prototype.propertiesSQL = function (model) {
    var self = this;3
    var sql = ['`id` INTEGER PRIMARY KEY'];3
    Object.keys(this._models[model].properties).forEach(function (prop) {
        sql.push('`' + prop + '` ' + self.propertySettingsSQL(model, prop));14
    });3
    return sql.join(',\n  ');3
};1
SQLite3.prototype.propertySettingsSQL = function (model, prop) {
    var p = this._models[model].properties[prop];14
    return datatype(p) + ' ' +14
    (p.allowNull === false || p['null'] === false ? 'NOT NULL' : 'NULL');
};1
function datatype(p) {
    switch (p.type.name) {
        case 'String':
        return 'VARCHAR(' + (p.limit || 255) + ')';5
        case 'Text':
        return 'TEXT';2
        case 'Number':
        return 'INT(11)';3
        case 'Date':
        return 'DATETIME';2
        case 'Boolean':
        return 'TINYINT(1)';2
    }
}