loopback-datasource-juggler/lib/model-builder.js

/*!
 * Module dependencies
 */

var inflection = require('inflection');
var EventEmitter = require('events').EventEmitter;
var util = require('util');
var assert = require('assert');
var DefaultModelBaseClass = require('./model.js');
var List = require('./list.js');
var ModelDefinition = require('./model-definition.js');
var mergeSettings = require('./utils').mergeSettings;

// Set up types
require('./types')(ModelBuilder);

var introspect = require('./introspection')(ModelBuilder);

/**
 * Export public API
 */
exports.ModelBuilder = exports.Schema = ModelBuilder;

/*!
 * Helpers
 */
var slice = Array.prototype.slice;

/**
 * ModelBuilder - A builder to define data models
 *
 * @constructor
 */
function ModelBuilder() {
    // create blank models pool
    /**
     * @property {Object} models Model constructors
     */
    this.models = {};
    /**
     * @property {Object} definitions Definitions of the models
     */
    this.definitions = {};
}

// Inherit from EventEmitter
util.inherits(ModelBuilder, EventEmitter);

// Create a default instance
ModelBuilder.defaultInstance = new ModelBuilder();

function isModelClass(cls) {
    if(!cls) {
        return false;
    }
    return cls.prototype instanceof DefaultModelBaseClass;
}

ModelBuilder.prototype.getModel = function(name) {
  return this.models[name];
};

ModelBuilder.prototype.getModelDefinition = function(name) {
  return this.definitions[name];
};

/**
 * Define a model 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 = modelBuilder.define('User', {
 *     email: String,
 *     password: String,
 *     birthDate: Date,
 *     activated: Boolean
 * });
 * ```
 * @example more advanced case
 * ```
 * var User = modelBuilder.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 }
 * });
 * ```
 */
ModelBuilder.prototype.define = function defineClass(className, properties, settings, parent) {
    var modelBuilder = this;
    var args = slice.call(arguments);
    var pluralName = settings && settings.plural;

    if (!className) {
        throw new Error('Class name required');
    }
    if (args.length === 1) {
        properties = {};
        args.push(properties);
    }
    if (args.length === 2) {
        settings   = {};
        args.push(settings);
    }

    properties = properties || {};
    settings = settings || {};

    // Set the strict mode to be false by default
    if(settings.strict === undefined || settings.strict === null) {
        settings.strict = false;
    }

    // Set up the base model class
    var ModelBaseClass = parent || DefaultModelBaseClass;
    var baseClass = settings.base || settings['super'];
    if(baseClass) {
        if(isModelClass(baseClass)) {
            ModelBaseClass = baseClass;
        } else {
            ModelBaseClass = this.models[baseClass];
            assert(ModelBaseClass, 'Base model is not found: ' + baseClass);
        }
    }

    // Check if there is a unresolved model with the same name
    var ModelClass = this.models[className];

    // Create the ModelClass if it doesn't exist or it's resolved (override)
    // TODO: [rfeng] We need to decide what names to use for built-in models such as User.
    if(!ModelClass || !ModelClass.settings.unresolved) {
        // every class can receive hash of data as optional param
        ModelClass = function ModelConstructor(data, dataSource) {
            if(!(this instanceof ModelConstructor)) {
                return new ModelConstructor(data, dataSource);
            }
            if(ModelClass.settings.unresolved) {
                throw new Error('Model ' + ModelClass.modelName + ' is not defined.');
            }
            ModelBaseClass.apply(this, arguments);
            if(dataSource) {
                hiddenProperty(this, '__dataSource', dataSource);
            }
        };
        // mix in EventEmitter (don't inherit from)
        var events = new EventEmitter();
        for (var f in EventEmitter.prototype) {
            if (typeof EventEmitter.prototype[f] === 'function') {
                ModelClass[f] = EventEmitter.prototype[f].bind(events);
            }
        }
        util.inherits(ModelClass, ModelBaseClass);
        hiddenProperty(ModelClass, 'modelName', className);
    }

    // store class in model pool
    this.models[className] = ModelClass;

    // Return the unresolved model
    if(settings.unresolved) {
        ModelClass.settings = {unresolved: true};
        return ModelClass;
    }

    // Add metadata to the ModelClass
    hiddenProperty(ModelClass, 'modelBuilder', modelBuilder);
    hiddenProperty(ModelClass, 'dataSource', modelBuilder); // Keep for back-compatibility
    hiddenProperty(ModelClass, 'pluralModelName', pluralName || inflection.pluralize(className));
    hiddenProperty(ModelClass, 'relations', {});

    // inherit ModelBaseClass static methods
    for (var i in ModelBaseClass) {
        // We need to skip properties that are already in the subclass, for example, the event emitter methods
        if(i !== '_mixins' && !(i in ModelClass)) {
            ModelClass[i] = ModelBaseClass[i];
        }
    }
    
    ModelClass.getter = {};
    ModelClass.setter = {};

    var modelDefinition = new ModelDefinition(this, className, properties, settings);

    this.definitions[className] = modelDefinition;
    
    // expose properties on the ModelClass
    ModelClass.definition = modelDefinition;
    // keep a pointer to settings as models can use it for configuration
    ModelClass.settings = modelDefinition.settings;

    var idInjection = settings.idInjection;
    if(idInjection !== false) {
        // Default to true if undefined
        idInjection = true;
    }

    var idNames = modelDefinition.idNames();
    if(idNames.length > 0) {
        // id already exists
        idInjection = false;
    }

    // Add the id property
    if (idInjection) {
        // Set up the id property
        ModelClass.definition.defineProperty('id', { type: Number, id: 1, generated: true });
    }

    idNames = modelDefinition.idNames(); // Reload it after rebuild
    // Create a virtual property 'id'
    if (idNames.length === 1) {
        var idProp = idNames[0];
        if (idProp !== 'id') {
            Object.defineProperty(ModelClass.prototype, 'id', {
                get: function () {
                    var idProp = ModelClass.definition.idNames[0];
                    return this.__data[idProp];
                },
                configurable: true,
                enumerable: false
            });
        }
    } else {
        // Now the id property is an object that consists of multiple keys
        Object.defineProperty(ModelClass.prototype, 'id', {
            get: function () {
                var compositeId = {};
                var idNames = ModelClass.definition.idNames();
                for (var p in idNames) {
                    compositeId[p] = this.__data[p];
                }
                return compositeId;
            },
            configurable: true,
            enumerable: false
        });
    }

    // A function to loop through the properties
    ModelClass.forEachProperty = function (cb) {
        Object.keys(ModelClass.definition.properties).forEach(cb);
    };

    // A function to attach the model class to a data source
    ModelClass.attachTo = function (dataSource) {
        dataSource.attach(this);
    };

    // A function to extend the model
    ModelClass.extend = function (className, subclassProperties, subclassSettings) {
        var properties = ModelClass.definition.properties;
        var settings = ModelClass.definition.settings;

        subclassProperties = subclassProperties || {};
        subclassSettings = subclassSettings || {};

        // Check if subclass redefines the ids
        var idFound = false;
        for(var k in subclassProperties) {
            if(subclassProperties[k].id) {
                idFound = true;
                break;
            }
        }

        // Merging the properties
        Object.keys(properties).forEach(function (key) {
          if(idFound && properties[key].id) {
              // don't inherit id properties
              return;
          }
          if(subclassProperties[key] === undefined) {
            subclassProperties[key] = properties[key];
          }
        });

        // Merge the settings
        subclassSettings = mergeSettings(settings, subclassSettings);

        /*
        Object.keys(settings).forEach(function (key) {
          if(subclassSettings[key] === undefined) {
            subclassSettings[key] = settings[key];
          }
        });
        */

        // Define the subclass
        var subClass = modelBuilder.define(className, subclassProperties, subclassSettings, ModelClass);

        // Calling the setup function
        if(typeof subClass.setup === 'function') {
          subClass.setup.call(subClass);
        }
        
        return subClass;
    };

    /**
     * Register a property for the model class
     * @param propertyName
     */
    ModelClass.registerProperty = function (propertyName) {
        var properties = modelDefinition.build();
        var prop = properties[propertyName];
        var DataType = prop.type;
        if(!DataType) {
            throw new Error('Invalid type for property ' + propertyName);
        }
        if (Array.isArray(DataType) || DataType === Array) {
            DataType = List;
        } else if (DataType.name === 'Date') {
            var OrigDate = Date;
            DataType = function Date(arg) {
                return new OrigDate(arg);
            };
        } else if(typeof DataType === 'string') {
            DataType = modelBuilder.resolveType(DataType);
        }
        
        if(prop.required) {
            var requiredOptions = typeof prop.required === 'object' ? prop.required : undefined;
            ModelClass.validatesPresenceOf(propertyName, requiredOptions);
        }

        Object.defineProperty(ModelClass.prototype, propertyName, {
            get: function () {
                if (ModelClass.getter[propertyName]) {
                    return ModelClass.getter[propertyName].call(this); // Try getter first
                } else {
                    return this.__data && this.__data[propertyName]; // Try __data
                }
            },
            set: function (value) {
                if (ModelClass.setter[propertyName]) {
                    ModelClass.setter[propertyName].call(this, value); // Try setter first
                } else {
                    if (!this.__data) {
                        this.__data = {};
                    }
                    if (value === null || value === undefined) {
                        this.__data[propertyName] = value;
                    } else {
                        if(DataType === List) {
                            this.__data[propertyName] = DataType(value, properties[propertyName].type, this.__data);
                        } else {
                            // Assume the type constructor handles Constructor() call
                            // If not, we should call new DataType(value).valueOf();
                            this.__data[propertyName] = DataType(value);
                        }
                    }
                }
            },
            configurable: true,
            enumerable: true
        });

        // <propertyName>$was --> __dataWas.<propertyName>
        Object.defineProperty(ModelClass.prototype, propertyName + '$was', {
            get: function () {
                return this.__dataWas && this.__dataWas[propertyName];
            },
            configurable: true,
            enumerable: false
        });

        // FIXME: [rfeng] Do we need to keep the raw data?
        // Use $ as the prefix to avoid conflicts with properties such as _id
        Object.defineProperty(ModelClass.prototype, '$' + propertyName, {
            get: function () {
                return this.__data && this.__data[propertyName];
            },
            set: function (value) {
                if (!this.__data) {
                    this.__data = {};
                }
                this.__data[propertyName] = value;
            },
            configurable: true,
            enumerable: false
        });
    };

    ModelClass.forEachProperty(ModelClass.registerProperty);

    ModelClass.emit('defined', ModelClass);

    return ModelClass;

};

/**
 * Define single property named `propertyName` on `model`
 *
 * @param {String} model - name of model
 * @param {String} propertyName - name of property
 * @param {Object} propertyDefinition - property settings
 */
ModelBuilder.prototype.defineProperty = function (model, propertyName, propertyDefinition) {
    this.definitions[model].defineProperty(propertyName, propertyDefinition);
    this.models[model].registerProperty(propertyName);
};

/**
 * Extend existing model with bunch of properties
 *
 * @param {String} model - name of model
 * @param {Object} props - hash of properties
 *
 * Example:
 *
 *     // Instead of doing this:
 *
 *     // amend the content model with competition attributes
 *     db.defineProperty('Content', 'competitionType', { type: String });
 *     db.defineProperty('Content', 'expiryDate', { type: Date, index: true });
 *     db.defineProperty('Content', 'isExpired', { type: Boolean, index: true });
 *
 *     // modelBuilder.extend allows to
 *     // extend the content model with competition attributes
 *     db.extendModel('Content', {
 *       competitionType: String,
 *       expiryDate: { type: Date, index: true },
 *       isExpired: { type: Boolean, index: true }
 *     });
 */
ModelBuilder.prototype.extendModel = function (model, props) {
    var t = this;
    Object.keys(props).forEach(function (propName) {
        var definition = props[propName];
        t.defineProperty(model, propName, definition);
    });
};


ModelBuilder.prototype.copyModel = function copyModel(Master) {
    var modelBuilder = this;
    var className = Master.modelName;
    var md = Master.modelBuilder.definitions[className];
    var Slave = function SlaveModel() {
        Master.apply(this, [].slice.call(arguments));
    };

    util.inherits(Slave, Master);

    Slave.__proto__ = Master;

    hiddenProperty(Slave, 'modelBuilder', modelBuilder);
    hiddenProperty(Slave, 'modelName', className);
    hiddenProperty(Slave, 'relations', Master.relations);

    if (!(className in modelBuilder.models)) {

        // store class in model pool
        modelBuilder.models[className] = Slave;
        modelBuilder.definitions[className] = {
            properties: md.properties,
            settings: md.settings
        };
    }

    return Slave;
};


/*!
 * Define hidden property
 */
function hiddenProperty(where, property, value) {
    Object.defineProperty(where, property, {
        writable: true,
        enumerable: false,
        configurable: true,
        value: value
    });
}

/**
 * Get the schema name
 */
ModelBuilder.prototype.getSchemaName = function (name) {
    if (name) {
        return name;
    }
    if (typeof this._nameCount !== 'number') {
        this._nameCount = 0;
    } else {
        this._nameCount++;
    }
    return 'AnonymousModel_' + this._nameCount;
};

/**
 * Resolve the type string to be a function, for example, 'String' to String
 * @param {String} type The type string, such as 'number', 'Number', 'boolean', or 'String'. It's case insensitive
 * @returns {Function} if the type is resolved
 */
ModelBuilder.prototype.resolveType = function(type) {
    if (!type) {
        return type;
    }
    if (Array.isArray(type) && type.length > 0) {
        // For array types, the first item should be the type string
        var itemType = this.resolveType(type[0]);
        if (typeof itemType === 'function') {
            return [itemType];
        }
        else {
            return itemType; // Not resolved, return the type string
        }
    }
    if (typeof type === 'string') {
        var schemaType = ModelBuilder.schemaTypes[type.toLowerCase()] || this.models[type];
        if (schemaType) {
            return schemaType;
        } else {
            // The type cannot be resolved, let's create a place holder
            type = this.define(type, {}, {unresolved: true});
            return type;
        }
    } else if (type.constructor.name === 'Object') {
        // We also support the syntax {type: 'string', ...}
        if (type.type) {
            return this.resolveType(type.type);
        } else {
            return this.define(this.getSchemaName(null),
                type, {anonymous: true, idInjection: false});
        }
    } else if('function' === typeof type ) {
        return type;
    }
    return type;
};

/**
 * Build models from schema definitions
 *
 * `schemas` can be one of the following:
 *
 * 1. An array of named schema definition JSON objects
 * 2. A schema definition JSON object
 * 3. A list of property definitions (anonymous)
 *
 * @param {*} schemas The schemas
 * @returns {Object} A map of model constructors keyed by model name
 */
ModelBuilder.prototype.buildModels = function (schemas) {
    var models = {};

    // Normalize the schemas to be an array of the schema objects {name: <name>, properties: {}, options: {}}
    if (!Array.isArray(schemas)) {
        if (schemas.properties && schemas.name) {
            // Only one item
            schemas = [schemas];
        } else {
            // Anonymous schema
            schemas = [
                {
                    name: this.getSchemaName(),
                    properties: schemas,
                    options: {anonymous: true}
                }
            ];
        }
    }

    var relations = [];
    for (var s in schemas) {
        var name = this.getSchemaName(schemas[s].name);
        schemas[s].name = name;
        var model = this.define(schemas[s].name, schemas[s].properties, schemas[s].options);
        models[name] = model;
        relations = relations.concat(model.definition.relations);
    }

    // Connect the models based on the relations
    for (var i = 0; i < relations.length; i++) {
        var relation = relations[i];
        var sourceModel = models[relation.source];
        var targetModel = models[relation.target];
        if (sourceModel && targetModel) {
            if(typeof sourceModel[relation.type] === 'function') {
                sourceModel[relation.type](targetModel, {as: relation.as});
            }
        }
    }
    return models;
};

/**
 * Introspect the json document to build a corresponding model
 * @param {String} name The model name
 * @param {Object} json The json object
 * @param [Object} options The options
 * @returns {}
 */
ModelBuilder.prototype.buildModelFromInstance = function(name, json, options) {

    // Introspect the JSON document to generate a schema
    var schema = introspect(json);

    // Create a model for the generated schema
    return this.define(name, schema, options);
};