/** * Module dependencies */ var AbstractClass = require('./abstract-class').AbstractClass; var util = require('util'); var path = require('path'); var fs = require('fs'); var existsSync = fs.existsSync || path.existsSync; /** * Export public API */ exports.Schema = Schema; // exports.AbstractClass = AbstractClass; /** * Helpers */ var slice = Array.prototype.slice; /** * Schema - adapter-specific classes factory. * * All classes in single schema shares same adapter type and * one database connection * * @param name - type of schema adapter (mysql, mongoose, sequelize, redis) * @param settings - any database-specific settings which we need to * establish connection (of course it depends on specific adapter) * * - host * - port * - username * - password * - database * - debug {Boolean} = false * * @example Schema creation, waiting for connection callback * ``` * var schema = new Schema('mysql', { database: 'myapp_test' }); * schema.define(...); * schema.on('connected', function () { * // work with database * }); * ``` */ function Schema(name, settings) { var schema = this; // just save everything we get this.name = name; this.settings = settings; // Disconnected by default this.connected = false; // create blank models pool this.models = {}; this.definitions = {}; // and initialize schema using adapter // this is only one initialization entry point of adapter // this module should define `adapter` member of `this` (schema) var adapter; if (existsSync(__dirname + '/adapters/' + name + '.js')) { adapter = require('./adapters/' + name); } else { try { adapter = require('jugglingdb-' + name); } catch (e) { throw new Error('Adapter ' + name + ' is not defined, try\n npm install ' + name); } } adapter.initialize(this, function () { // we have an adaper now? if (!this.adapter) { throw new Error('Adapter is not defined correctly: it should create `adapter` member of schema'); } this.adapter.log = function (query, start) { schema.log(query, start); }; this.adapter.logger = function (query) { var t1 = Date.now(); var log = this.log; return function (q) { log(q || query, t1); }; }; this.connected = true; this.emit('connected'); }.bind(this)); }; util.inherits(Schema, require('events').EventEmitter); function Text() {} Schema.Text = Text; function JSON() {} Schema.JSON = JSON; /** * Define class * * @param {String} className * @param {Object} properties - hash of class properties in format * `{property: Type, property2: Type2, ...}` * or * `{property: {type: Type}, property2: {type: Type2}, ...}` * @param {Object} settings - other configuration of class * @return newly created class * * @example simple case * ``` * var User = schema.define('User', { * email: String, * password: String, * birthDate: Date, * activated: Boolean * }); * ``` * @example more advanced case * ``` * var User = schema.define('User', { * email: { type: String, limit: 150, index: true }, * password: { type: String, limit: 50 }, * birthDate: Date, * registrationDate: {type: Date, default: function () { return new Date }}, * activated: { type: Boolean, default: false } * }); * ``` */ Schema.prototype.define = function defineClass(className, properties, settings) { var schema = this; var args = slice.call(arguments); if (!className) throw new Error('Class name required'); if (args.length == 1) properties = {}, args.push(properties); if (args.length == 2) settings = {}, args.push(settings); standartize(properties, settings); // every class can receive hash of data as optional param var NewClass = function ModelConstructor(data) { if (!(this instanceof ModelConstructor)) { return new ModelConstructor(data); } AbstractClass.call(this, data); }; hiddenProperty(NewClass, 'schema', schema); hiddenProperty(NewClass, 'modelName', className); hiddenProperty(NewClass, 'cache', {}); hiddenProperty(NewClass, 'mru', []); // inherit AbstractClass methods for (var i in AbstractClass) { NewClass[i] = AbstractClass[i]; } for (var j in AbstractClass.prototype) { NewClass.prototype[j] = AbstractClass.prototype[j]; } NewClass.getter = {}; NewClass.setter = {}; // store class in model pool this.models[className] = NewClass; this.definitions[className] = { properties: properties, settings: settings }; // pass controll to adapter this.adapter.define({ model: NewClass, properties: properties, settings: settings }); NewClass.prototype.__defineGetter__('id', function () { return this.__data.id; }); properties.id = properties.id || { type: Number }; NewClass.forEachProperty = function (cb) { Object.keys(properties).forEach(cb); }; NewClass.registerProperty = function (attr) { Object.defineProperty(NewClass.prototype, attr, { get: function () { if (NewClass.getter[attr]) { return NewClass.getter[attr].call(this); } else { return this.__data[attr]; } }, set: function (value) { if (NewClass.setter[attr]) { NewClass.setter[attr].call(this, value); } else { this.__data[attr] = value; } }, configurable: true, enumerable: true }); NewClass.prototype.__defineGetter__(attr + '_was', function () { return this.__dataWas[attr]; }); Object.defineProperty(NewClass.prototype, '_' + attr, { get: function () { return this.__data[attr]; }, set: function (value) { this.__data[attr] = value; }, configurable: true, enumerable: false }); }; NewClass.forEachProperty(NewClass.registerProperty); return NewClass; function standartize(properties, settings) { Object.keys(properties).forEach(function (key) { var v = properties[key]; if ( typeof v === 'function' || typeof v === 'object' && v && v.constructor.name === 'Array' ) { properties[key] = { type: v }; } }); // TODO: add timestamps fields // when present in settings: {timestamps: true} // or {timestamps: {created: 'created_at', updated: false}} // by default property names: createdAt, updatedAt } }; /** * Define single property named `prop` on `model` * * @param {String} model - name of model * @param {String} prop - name of propery * @param {Object} params - property settings */ Schema.prototype.defineProperty = function (model, prop, params) { this.definitions[model].properties[prop] = params; this.models[model].registerProperty(prop); if (this.adapter.defineProperty) { this.adapter.defineProperty(model, prop, params); } }; /** * Drop each model table and re-create. * This method make sense only for sql adapters. * * @warning All data will be lost! Use autoupdate if you need your data. */ Schema.prototype.automigrate = function (cb) { this.freeze(); if (this.adapter.automigrate) { this.adapter.automigrate(cb); } else if (cb) { cb(); } }; /** * Update existing database tables. * This method make sense only for sql adapters. */ Schema.prototype.autoupdate = function (cb) { this.freeze(); if (this.adapter.autoupdate) { this.adapter.autoupdate(cb); } else if (cb) { cb(); } }; /** * Check whether migrations needed * This method make sense only for sql adapters. */ Schema.prototype.isActual = function (cb) { this.freeze(); if (this.adapter.isActual) { this.adapter.isActual(cb); } else if (cb) { cb(null, true); } }; /** * Log benchmarked message. Do not redefine this method, if you need to grab * chema logs, use `schema.on('log', ...)` emitter event * * @private used by adapters */ Schema.prototype.log = function (sql, t) { this.emit('log', sql, t); }; /** * Freeze schema. Behavior depends on adapter */ Schema.prototype.freeze = function freeze() { if (this.adapter.freezeSchema) { this.adapter.freezeSchema(); } } /** * Return table name for specified `modelName` * @param {String} modelName */ Schema.prototype.tableName = function (modelName) { return this.definitions[modelName].settings.table = this.definitions[modelName].settings.table || modelName }; /** * Define foreign key * @param {String} className * @param {String} key - name of key field */ Schema.prototype.defineForeignKey = function defineForeignKey(className, key) { // quit if key already defined if (this.definitions[className].properties[key]) return; if (this.adapter.defineForeignKey) { this.adapter.defineForeignKey(className, key, function (err, keyType) { if (err) throw err; this.definitions[className].properties[key] = {type: keyType}; }.bind(this)); } else { this.definitions[className].properties[key] = {type: Number}; } this.models[className].registerProperty(key); }; /** * Close database connection */ Schema.prototype.disconnect = function disconnect() { if (typeof this.adapter.disconnect === 'function') { this.connected = false; this.adapter.disconnect(); } }; /** * Define hidden property */ function hiddenProperty(where, property, value) { Object.defineProperty(where, property, { writable: false, enumerable: false, configurable: false, value: value }); } /** * 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 }); }