alchemymvc 1.2.1 → 1.2.2

package/lib/app/helper_component/paginate_component.js

@@ -8,151 +8,98 @@
  * @since         0.0.1
  * @version       1.0.0
  */
-var Paginate = Function.inherits('Alchemy.Client.Component', function Paginate(controller, options) {
-	Paginate.super.call(this, controller, options);
-});
+const Paginate = Function.inherits('Alchemy.Client.Component', 'Paginate');
 
 /**
  * Perform a query
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.0.1
- * @version  1.0.6
+ * @version  1.2.2
  *
  * @param   {Model}     model
- * @param   {Object}    options
- * @param   {Function}  callback
+ * @param   {Criteria}  criteria
  *
  * @return  {Pledge}
  */
-Paginate.setMethod(function find(model, options, callback) {
-
-	var that = this,
-	    conduit = this.controller.conduit,
-	    conditions,
-	    last_id,
-	    filter,
-	    pledge,
-	    order,
-	    name,
-	    sort;
+Paginate.setMethod(function find(model, criteria) {
+
+	const conduit = this.controller.conduit;
 
 	// Get the model if a name has been given
 	if (typeof model == 'string') {
 		model = this.getModel(model);
 	}
 
-	// Make sure callback is set correctly
-	if (typeof options == 'function') {
-		callback = options;
-	}
-
-	// Make sure options is an object
-	if (!options || typeof options != 'object') {
-		options = {};
-	}
-
-	// Set the name for this pagination
-	if (!options.name) {
-		options.name = model.name;
-	} else {
-		options.name = options.name.modelName();
-	}
+	let page_size = criteria.options.page_size || 10,
+	    skipless = criteria.options.skipless,
+		last_id,
+	    name = criteria.options.name,
+		page = criteria.options.page;
 
-	if (!options.pageSize) {
-		options.pageSize = 10;
+	if (!name) {
+		name = model.name;
+		criteria.setOption('name', name);
 	}
 
-	if (options.skipless) {
-		last_id = options.last_id || conduit.param('page');
+	if (skipless) {
+		let sort;
+		last_id = criteria.options.last_id || conduit.param('page');
 
 		// When it's a skipless pagination,
 		// a sort is always implied
-		if (options.skipless === true) {
+		if (skipless === true) {
 			sort = {_id: 1};
 		} else {
 			sort = {};
-			sort[options.skipless] = 1;
+			sort[skipless] = 1;
 		}
 
-		options.sort = sort;
-
+		criteria.sort(sort);
 	} else {
 
 		// If no page has been given
-		if (typeof options.page != 'number') {
-			options.page = conduit.param('page');
+		if (typeof page != 'number') {
+			page = conduit.param('page');
 		}
 
-		if (options.page < 0 || !options.page) {
-			options.page = 1;
+		if (page < 0 || !page) {
+			page = 1;
 		}
 
-		options.offset = (options.page-1) * options.pageSize;
-
-		sort = conduit.param('sort');
+		let sort = conduit.param('sort');
 
 		if (sort) {
 			// Always override the sort
-			options.sort = {};
+			let new_sort = {};
 
 			order = conduit.param('order');
 
 			if (typeof order == 'string' && order.toLowerCase() == 'desc') {
-				options.sort[sort] = -1;
+				new_sort[sort] = -1;
 			} else {
-				options.sort[sort] = 1;
+				new_sort[sort] = 1;
 			}
-		}
-	}
-
-	options.limit = options.pageSize;
 
-	if (conduit.param('filter_field') && conduit.param('filter_value')) {
-		conditions = {};
-		conditions[conduit.param('filter_field')] = RegExp.interpret('/.*' + conduit.param('filter_value') + '.*/i');
-		options.conditions = conditions;
-	}
-
-	filter = conduit.param('filter');
-
-	if (filter) {
-		if (!conditions) {
-			conditions = {};
+			criteria.sort(new_sort);
 		}
 
-		options.conditions = conditions;
-
-		for (name in filter) {
-			if (filter[name] !== '') {
-				conditions[name] = RegExp.interpret('/.*' + filter[name] + '.*/i');
-			}
+		if (page) {
+			criteria.page(page, page_size);
 		}
 	}
 
 	if (last_id) {
-		if (!options.conditions) {
-			options.conditions = {};
-		}
-
-		if (!options.conditions.$and) {
-			options.conditions.$and = [];
-		}
-
-		let entry = {};
-
-		if (options.skipless === true) {
-			entry._id = {$gt: alchemy.castObjectId(last_id)};
+		if (skipless === true) {
+			criteria.where('_id').gt(last_id);
 		} else {
-			entry[options.skipless] = {$gt: last_id};
+			criteria.where(skipless).gt(last_id);
 		}
-
-		options.conditions.$and.push(entry);
 	}
 
-	options.available = true;
+	criteria.setOption('available', true);
 
-	pledge = model.find('all', options, function findAllPaginate(err, result) {
+	let pledge = model.find('all', criteria, function findAllPaginate(err, result) {
 
 		if (err) {
 			return;
@@ -166,21 +113,19 @@ Paginate.setMethod(function find(model, options, callback) {
 		}
 
 		let entry = {
-			page     : options.page,
-			size     : options.pageSize,
+			page     : page,
+			size     : page_size,
 			items    : result.available,
-			pages    : Math.ceil(result.available/options.pageSize),
-			skipless : options.skipless
+			pages    : Math.ceil(result.available/page_size),
+			skipless : skipless
 		};
 
-		if (options.skipless && result.length) {
+		if (skipless && result.length) {
 			entry.last_id = result.last()._id;
 		}
 
-		PageInfo[options.name] = entry;
+		PageInfo[name] = entry;
 	});
 
-	pledge.handleCallback(callback);
-
 	return pledge;
 });

package/lib/app/helper_controller/conduit.js

@@ -34,7 +34,7 @@ var Conduit = Function.inherits('Alchemy.Client.Base', 'Alchemy.Client.Conduit',
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    1.1.0
- * @version  1.1.0
+ * @version  1.2.2
  *
  * @param    {RURL}     url
  * @param    {Object}   options
@@ -121,17 +121,19 @@ Conduit.setStatic(function handleUrlLocal(url, options) {
 		conduit = new Conduit(url, options);
 	}
 
-	for (let key in options) {
-		let info = Blast.Classes.Develry.Request.getMethodInfo(key);
+	if (conduit) {
+		for (let key in options) {
+			let info = Blast.Classes.Develry.Request.getMethodInfo(key);
 
-		if (info && info.method != 'GET') {
-			conduit.method = info.method.toLowerCase();
-			break;
+			if (info && info.method != 'GET') {
+				conduit.method = info.method.toLowerCase();
+				break;
+			}
 		}
-	}
 
-	if (!conduit.method) {
-		conduit.method = 'get';
+		if (!conduit.method) {
+			conduit.method = 'get';
+		}
 	}
 
 	Function.series(tasks, function done(err) {

package/lib/app/helper_datasource/00-nosql_datasource.js

@@ -590,7 +590,7 @@ NoSQL.setStatic(function areComparable(a, b) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    1.1.0
- * @version  1.1.2
+ * @version  1.2.2
  *
  * @param    {Criteria}   criteria
  * @param    {Group}      group
@@ -798,6 +798,10 @@ NoSQL.setMethod(function compileCriteria(criteria, group) {
 						{$exists: exists}
 					];
 
+					if (!entry.field) {
+						throw new Error('Could not find field for path "' + entry.target_path + '" in model ' + entry.model.name);
+					}
+
 					if (entry.field.is_array) {
 						$or.push({[comparator]: []});
 					} else if (entry.field instanceof Classes.Alchemy.Field.String) {

package/lib/app/helper_field/05-string_field.js

@@ -7,9 +7,7 @@
  * @since    0.2.0
  * @version  1.1.0
  */
-var StringField = Function.inherits('Alchemy.Field', function String(schema, name, options) {
-	String.super.call(this, schema, name, options);
-});
+var StringField = Function.inherits('Alchemy.Field', 'String');
 
 /**
  * Set the datatype name

package/lib/app/helper_field/belongsto_field.js

@@ -7,23 +7,4 @@
  * @since    0.2.0
  * @version  1.1.0
  */
-var BelongsTo = Function.inherits('Alchemy.Field.ObjectId', function BelongsTo(schema, name, options) {
-	BelongsTo.super.call(this, schema, name, options);
-
-	// @todo: set index stuff
-});
-
-/**
- * Load remote data for some fields
- *
- * @author   Jelle De Loecker   <jelle@elevenways.be>
- * @since    0.2.0
- * @version  0.2.0
- *
- * @param    {Object}   config
- */
-BelongsTo.setMethod(async function loadData(config) {
-
-	
-
-});
+const BelongsTo = Function.inherits('Alchemy.Field.ObjectId', 'BelongsTo');

package/lib/app/helper_model/data_provider.js

@@ -0,0 +1,92 @@
+/**
+ * The DataProvider class
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.2
+ * @version  1.2.2
+ */
+const DataProvider = Function.inherits('Alchemy.Base', 'Alchemy.DataProvider', function DataProvider(config) {
+	this.config = config || {};
+});
+
+
+/**
+ * Undry
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.2.2
+ * @version  1.2.2
+ *
+ * @param    {Object}           obj
+ * @param    {Boolean|String}   cloned
+ *
+ * @return   {DataProvider}
+ */
+DataProvider.setStatic(function unDry(obj) {
+	let result = new this(obj.config);
+	return result;
+});
+
+/**
+ * Configure a new config
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.2.2
+ * @version  1.2.2
+ */
+DataProvider.setStatic(function addConfig(name, default_value) {
+	this.setProperty(name, function getValue() {
+
+		if (this.config[name] != null) {
+			return this.config[name];
+		}
+
+		return default_value;
+	}, function setValue(value) {
+		return this.config[name] = value;
+	});
+});
+
+/**
+ * The wanted page size
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.2.2
+ * @version  1.2.2
+ */
+DataProvider.addConfig('page_size');
+
+/**
+ * Get all the data
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.2.2
+ * @version  1.2.2
+ */
+DataProvider.setAbstractMethod('getAll');
+
+/**
+ * Get the data for the given page (pages are 1-index based)
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.2.2
+ * @version  1.2.2
+ */
+DataProvider.setAbstractMethod('getPage');
+
+/**
+ * Return an object for json-drying this document
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.2.2
+ * @version  1.2.2
+ *
+ * @return   {Object}
+ */
+DataProvider.setMethod(function toDry() {
+	return {
+		value : {
+			config : this.config,
+		}
+	};
+});

package/lib/app/helper_model/field_config.js

@@ -29,6 +29,9 @@ const FieldConfig = Fn.inherits('Alchemy.Base', 'Alchemy.Criteria', function Fie
 	// The association this belongs to
 	this.association = null;
 
+	// The main model this field is in
+	this.model = null;
+
 	this.options = options || {};
 
 	if (path) {
@@ -72,6 +75,94 @@ FieldConfig.setProperty(function title() {
 	return title;
 });
 
+/**
+ * Set the main model context this field is used for
+ * (Actual field can be in an association of this model)
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.2
+ * @version  1.2.2
+ *
+ * @param    {String|Model}   model
+ */
+FieldConfig.setMethod(function setContextModel(model) {
+
+	if (typeof model == 'string') {
+		this.model = model;
+		this._model = alchemy.getModel(model);
+	} else {
+		this._model = model;
+		this.model = model.model_name;
+	}
+});
+
+/**
+ * Get the context model this field is used for
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.2
+ * @version  1.2.2
+ */
+FieldConfig.setMethod(function getContextModel() {
+
+	if (this._model) {
+		return this._model;
+	}
+
+	if (!this.model) {
+		return;
+	}
+
+	this._model = alchemy.getModel(this.model);
+	return this._model;
+});
+
+/**
+ * Get the actual model this field is in
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.2
+ * @version  1.2.2
+ */
+FieldConfig.setMethod(function getModel() {
+
+	let model = this.getContextModel();
+
+	if (!model) {
+		return;
+	}
+
+	if (this.association) {
+		let config = model.getAssociation(this.association);
+
+		if (config) {
+			model = alchemy.getModel(config.modelName);
+		} else {
+			model = null;
+		}
+	}
+
+	return model;
+});
+
+/**
+ * Get the field definition
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.2
+ * @version  1.2.2
+ */
+FieldConfig.setMethod(function getFieldDefinition() {
+
+	let model = this.getModel();
+
+	if (!model) {
+		return;
+	}
+
+	return model.getField(this.local_path);
+});
+
 /**
  * Return an object for json-drying this list
  *

package/lib/app/helper_model/field_set.js

@@ -143,6 +143,28 @@ FieldSet.setMethod(function toJSON() {
 	return result;
 });
 
+/**
+ * Get an instance of the model
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.2
+ * @version  1.2.2
+ *
+ * @return   {Model}
+ */
+FieldSet.setMethod(function getModel() {
+
+	if (!this.model) {
+		return;
+	}
+
+	if (!this._model) {
+		this._model = alchemy.getModel(this.model);
+	}
+
+	return this._model;
+});
+
 /**
  * Iterator method
  *
@@ -165,7 +187,7 @@ FieldSet.setMethod(Symbol.iterator, function* iterate() {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.1.3
- * @version  1.1.3
+ * @version  1.2.2
  *
  * @param    {String}   name      The name of the field to add
  * @param    {Object}   options
@@ -176,6 +198,10 @@ FieldSet.setMethod(function addField(name, options) {
 
 	let config = new Classes.Alchemy.Criteria.FieldConfig(name, options);
 
+	if (this.model && !config.getContextModel()) {
+		config.setContextModel(this.model);
+	}
+
 	this.fields.set(name, config);
 
 	return config;

package/lib/app/helper_model/remote_data_provider.js

@@ -0,0 +1,35 @@
+/**
+ * The Remote DataProvider class
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.2
+ * @version  1.2.2
+ */
+const RemoteDataProvider = Function.inherits('Alchemy.DataProvider', 'Remote');
+
+/**
+ * The url to load
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.2.2
+ * @version  1.2.2
+ */
+RemoteDataProvider.addConfig('source');
+
+/**
+ * Get all the data
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.2.2
+ * @version  1.2.2
+ */
+RemoteDataProvider.setMethod(async function getAll() {
+
+	if (!this.source) {
+		return [];
+	}
+
+	let result = await Blast.fetch(this.source);
+
+	return result;
+});

package/lib/bootstrap.js

@@ -3,6 +3,22 @@
 var libpath = require('path'),
     starting;
 
+/**
+ * Calling dynamic `import()` from certain places in the codebase actually
+ * causes segfaults. This is a workaround for that.
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.2
+ * @version  1.2.2
+ *
+ * @param    {String}   path
+ *
+ * @return   {Promise}
+ */
+global.doImport = function doImport(path) {
+	return import(path);
+};
+
 /**
  * Extend prototypes
  */

package/lib/class/schema.js

@@ -287,7 +287,7 @@ Schema.setMethod(function getAssociationArguments(locality, alias, modelName, op
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.2.2
  *
  * @param    {String}   alias
  * @param    {String}   modelname
@@ -369,7 +369,14 @@ Schema.setMethod(function addAssociation(type, alias, modelName, options) {
 	if (locality == 'internal') {
 
 		if (!this.getField(options.localKey)) {
-			this.addField(options.localKey, type, args);
+			let field_options = Object.assign({}, args);
+
+			if (options && options.field_options) {
+				Object.assign(field_options, options.field_options);
+				field_options.field_options = undefined;
+			}
+
+			this.addField(options.localKey, type, field_options);
 
 			if (constructor) {
 				doc_class.setFieldGetter(options.localKey);

package/lib/core/base.js

@@ -416,19 +416,28 @@ Base.setMethod(function getClassPathAfter(after) {
 /**
  * Call a method if it exists or do the callback
  *
- * @author   Jelle De Loecker <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
- * @version  1.0.0
+ * @version  1.2.2
  */
 Base.setMethod(function callOrNext(name, args, next) {
 
+	if (arguments.length == 2 && typeof args == 'function') {
+		next = args;
+		args = [];
+	}
+
 	if (typeof this[name] == 'function') {
 
 		if (next) {
 			args.push(next);
 		}
 
-		this[name].apply(this, args);
+		try {
+			this[name].apply(this, args);
+		} catch (err) {
+			next(err);
+		}
 	} else if (next) {
 		next();
 

package/lib/init/alchemy.js

@@ -751,7 +751,6 @@ Alchemy.setMethod(function use(module_name, register_as, options) {
 	return module;
 });
 
-
 /**
  * Look for a module by traversing the filesystem
  *
@@ -878,7 +877,7 @@ Alchemy.setMethod(function searchModule(startPath, moduleName, recurse) {
  * 
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.0.1
- * @version  1.1.0
+ * @version  1.2.2
  *
  * @param    {String}   moduleName
  * @param    {Object}   options
@@ -949,20 +948,26 @@ Alchemy.setMethod(function findModule(moduleName, options) {
 	// If the module_path was found, actually require the module
 	if (module_path) {
 
-		// Modules are required by default
-		if (options.require) {
-			module = require(module_path);
-		}
-
 		// Get the package.json file
 		if (~module_path.indexOf(libpath.sep)) {
 			internal = false;
 
+			let last_piece = moduleName.split(libpath.sep).last(),
+			    package_path;
+			
 			let module_dir = libpath.dirname(module_path);
 			result.module_dir = module_dir;
 
+			// If the path doesn't end with the module name, look for it
+			if (!module_path.endsWith(last_piece)) {
+				package_path = module_path.beforeLast(last_piece) + last_piece;
+				package_path = libpath.resolve(package_path, 'package.json');
+			} else {
+				package_path = libpath.resolve(module_dir, 'package.json');
+			}	
+
 			try {
-				package_json = require(libpath.resolve(module_dir, 'package.json'));
+				package_json = require(package_path);
 			} catch (err) {
 				package_json = false;
 			}
@@ -972,6 +977,15 @@ Alchemy.setMethod(function findModule(moduleName, options) {
 				version: process.versions.node
 			};
 		}
+
+		// Modules are required by default
+		if (options.require) {
+			if (package_json && package_json.type == 'module' && !(package_json.main && package_json.module)) {
+				module = doImport(module_path)
+			} else {
+				module = require(module_path);
+			}
+		}
 	}
 
 	if (!options.require || module) {

package/lib/init/functions.js

@@ -1082,7 +1082,7 @@ Alchemy.setMethod(function downloadFile(url, options, callback) {
 		file = fs.createWriteStream(filepath);
 
 		if (res.statusCode == 404) {
-			err = new Error('Path does not exist');
+			err = new Error('Path "' + url + '" does not exist');
 			err.number = 404;
 
 			return callback(err);

package/lib/init/load_functions.js

@@ -813,7 +813,7 @@ Alchemy.setMethod(function startPlugins(names) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.0.1
- * @version  1.1.0
+ * @version  1.2.2
  *
  * @param    {String|Array}   names
  * @param    {Boolean}        attempt_require
@@ -844,8 +844,13 @@ Alchemy.setMethod(function requirePlugin(names, attempt_require) {
 				temp = alchemy.usePlugin(name);
 
 				if (temp) {
-					// Also start the plugin!
-					alchemy.startPlugins(name);
+					let plugin_stage = alchemy.sputnik.get('plugins');
+
+					if (!plugin_stage || plugin_stage.started) {
+						// If the plugin stage has already started,
+						// manually start this plugin now
+						alchemy.startPlugins(name);
+					}
 					continue;
 				}
 			}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "alchemymvc",
 	"description": "MVC framework for Node.js",
-	"version": "1.2.1",
+	"version": "1.2.2",
 	"author": "Jelle De Loecker <jelle@elevenways.be>",
 	"keywords": [
 		"alchemy",
@@ -22,7 +22,7 @@
 		"chokidar"         : "~3.5.3",
 		"formidable"       : "~1.2.2",
 		"graceful-fs"      : "~4.2.9",
-		"hawkejs"          : "~2.2.3",
+		"hawkejs"          : "~2.2.8",
 		"jsondiffpatch"    : "~0.4.1",
 		"mime"             : "~3.0.0",
 		"minimist"         : "~1.2.5",