alchemymvc 1.1.7 → 1.2.0

package/lib/class/datasource.js

@@ -165,7 +165,7 @@ Datasource.setMethod(function getSchema(schema) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.2.0
  *
  * @param    {Schema|Model}   schema
  * @param    {Object}         data
@@ -187,7 +187,7 @@ Datasource.setMethod(function toDatasource(schema, data, callback) {
 	}
 
 	if (!schema) {
-		log.todo('Schema not found: not normalizing data');
+		log.todo('Schema not found: not normalizing data', data);
 		pledge = Pledge.resolve(data);
 		pledge.done(callback);
 		return pledge;
@@ -285,6 +285,12 @@ Datasource.setMethod(function toApp(schema, query, options, data, callback) {
 		return pledge;
 	}
 
+	options = Object.assign({}, options);
+
+	if (!options._root_data) {
+		options._root_data = data;
+	}
+
 	if (data[schema.name]) {
 		tasks = {};
 
@@ -338,12 +344,6 @@ Datasource.setMethod(function toApp(schema, query, options, data, callback) {
 	data = Object.assign({}, data);
 	tasks = {};
 
-	options = Object.assign({}, options);
-
-	if (!options._root_data) {
-		options._root_data = data;
-	}
-
 	Object.each(data, function eachField(value, fieldName) {
 
 		var field = schema.get(fieldName);

package/lib/class/field.js

@@ -594,7 +594,7 @@ Field.setMethod(function castCondition(value, field_paths) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.5.0
- * @version  1.0.7
+ * @version  1.2.0
  *
  * @param    {Mixed}   value
  * @param    {Array}   field_paths   The path to the field
@@ -602,6 +602,12 @@ Field.setMethod(function castCondition(value, field_paths) {
  * @return   {Mixed}
  */
 Field.setMethod(function _castCondition(value, field_paths) {
+
+	// Always allow regex values, we'll use those in the projection stage
+	if (value && RegExp.isRegExp(value)) {
+		return value;
+	}
+
 	return this.cast(value, true);
 });
 

package/lib/class/inode.js

@@ -137,4 +137,66 @@ Inode.setProperty(function rootname() {
 	}
 
 	return libpath.basename(this.name, extension);
+});
+
+/**
+ * Get the stat object
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.1.8
+ * @version  1.1.8
+ *
+ * @param    {boolean}   refresh
+ *
+ * @return   {Pledge<fs.Stats>}
+ */
+Inode.setMethod(function getStats(refresh) {
+
+	if (!refresh && this.stat) {
+		return Pledge.resolve(this.stat);
+	}
+
+	let pledge = new Pledge();
+
+	fs.stat(this.path, (err, stat) => {
+
+		if (err) {
+			return pledge.reject(err);
+		}
+
+		this.stat = stat;
+		pledge.resolve(stat);
+	});
+
+	return pledge;
+});
+
+/**
+ * Does this inode still exist?
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.1.8
+ * @version  1.1.8
+ *
+ * @return   {boolean}
+ */
+Inode.setMethod(async function exists() {
+
+	let stat;
+
+	try {
+		stat = await this.getStats(true);
+	} catch (err) {
+		if (err.code == 'ENOENT') {
+			return false;
+		} else {
+			return null;
+		}
+	}
+
+	if (!stat) {
+		return false;
+	}
+
+	return true;
 });

package/lib/class/inode_dir.js

@@ -1,3 +1,5 @@
+const libpath = alchemy.use('path');
+
 /**
  * The Directory class
  *
@@ -108,3 +110,116 @@ Directory.setMethod(Symbol.iterator, function* iterate() {
 		yield this.contents.entries[i];
 	}
 });
+
+/**
+ * Get a file from this directory, or its subdirectory
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.1.8
+ * @version  1.1.8
+ *
+ * @param    {string|string[]}   path
+ *
+ * @return   {Alchemy.Inode}
+ */
+Directory.setMethod(async function get(path) {
+
+	if (!Array.isArray(path)) {
+		path = path.split(libpath.sep);
+	}
+
+	if (!this.contents.length) {
+		await this.loadContents();
+	}
+
+	let current,
+	    result = this,
+	    piece,
+	    entry;
+
+	for (piece of path) {
+		current = result;
+		result = null;
+
+		// If the current piece isn't a directory we can end now
+		if (!current.is_directory) {
+			break;
+		}
+
+		// Loop over all the entries of the current directory
+		for (entry of current) {
+			if (piece == entry.name) {
+				result = entry;
+				break;
+			}
+		}
+
+		if (!result) {
+			return null;
+		}
+	}
+
+	return result;
+});
+
+/**
+ * Return a list of all files
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.1.8
+ * @version  1.1.8
+ *
+ * @return   {Alchemy.Inode.List}
+ */
+Directory.setMethod(async function flatten() {
+
+	if (!this.contents.length) {
+		await this.loadContents({recursive: true});
+	}
+
+	let info = {
+		start : this.path,
+		seen  : new Set(),
+		list  : new Classes.Alchemy.Inode.List([]),
+	};
+
+	flattenFiles(this, info);
+
+	return info.list;
+});
+
+/**
+ * Add all files to the given list
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.1.8
+ * @version  1.1.8
+ *
+ * @param    {Alchemy.Inode.Directory}   current
+ * @param    {Object}                    info
+ *
+ * @return   {Alchemy.Inode.List}
+ */
+function flattenFiles(current, info) {
+
+	if (info.seen.has(current.path)) {
+		return;
+	}
+
+	info.seen.add(current.path);
+
+	let entry,
+	    dirs = [];
+
+	for (entry of current) {
+		if (entry.is_file) {
+			info.list.entries.push(entry);
+		} else {
+			dirs.push(entry);
+		}
+	}
+
+	for (entry of dirs) {
+		flattenFiles(entry, info);
+	}
+}

package/lib/class/inode_file.js

@@ -1,112 +1,113 @@
-const fs = alchemy.use('fs');
-
-/**
- * The File class
- *
- * @constructor
- *
- * @author   Jelle De Loecker   <jelle@elevenways.be>
- * @since    1.1.0
- * @version  1.1.0
- *
- * @param    {String}   path   Path to the file
- */
-var File = Function.inherits('Alchemy.Inode', function File(path) {
-
-	if (typeof path == 'object') {
-		return File.from(path);
-	}
-
-	this.type = null;
-	this.hash = null;
-
-	File.super.call(this, path);
-});
-
-/**
- * Files are obviously files
- *
- * @author   Jelle De Loecker   <jelle@develry.be>
- * @since    1.1.0
- * @version  1.1.0
- *
- * @type     {Boolean}
- */
-File.setProperty('is_file', true);
-
-/**
- * Create a File instance from the given variable
- *
- * @author   Jelle De Loecker   <jelle@develry.be>
- * @since    1.1.0
- * @version  1.1.0
- */
-File.setStatic(function from(obj) {
-
-	var file,
-	    path;
-
-	if (typeof obj == 'string') {
-		path = obj;
-		obj = null;
-	} else {
-		path = obj.path;
-	}
-
-	file = new File(path);
-
-	if (obj) {
-		file.stat = {
-			size : obj.size
-		};
-
-		file.name = obj.name;
-		file.type = obj.type;
-		file.hash = obj.hash;
-	}
-
-	return file;
-});
-
-/**
- * Read and return the contents
- *
- * @author   Jelle De Loecker   <jelle@develry.be>
- * @since    1.1.0
- * @version  1.1.0
- */
-File.setMethod(function read(options) {
-
-	let pledge = new Pledge();
-
-	if (!options) {
-		options = {flag: 'r'};
-	}
-
-	fs.readFile(this.path, options, function done(err, data) {
-
-		if (err) {
-			return pledge.reject(err);
-		}
-
-		pledge.resolve(data);
-	});
-
-	return pledge;
-});
-
-/**
- * Read and return the contents as a string
- *
- * @author   Jelle De Loecker   <jelle@develry.be>
- * @since    1.1.0
- * @version  1.1.0
- */
-File.setMethod(function readString(encoding) {
-
-	if (!encoding) {
-		encoding = 'utf8';
-	}
-
-	return this.read({encoding: encoding});
+const fs = alchemy.use('fs');
+
+/**
+ * The File class
+ *
+ * @constructor
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.1.0
+ * @version  1.1.0
+ *
+ * @param    {String}   path   Path to the file
+ */
+var File = Function.inherits('Alchemy.Inode', function File(path) {
+
+	if (typeof path == 'object') {
+		return File.from(path);
+	}
+
+	this.type = null;
+	this.hash = null;
+
+	File.super.call(this, path);
+});
+
+/**
+ * Files are obviously files
+ *
+ * @author   Jelle De Loecker   <jelle@develry.be>
+ * @since    1.1.0
+ * @version  1.1.0
+ *
+ * @type     {Boolean}
+ */
+File.setProperty('is_file', true);
+
+/**
+ * Create a File instance from the given variable
+ *
+ * @author   Jelle De Loecker   <jelle@develry.be>
+ * @since    1.1.0
+ * @version  1.2.0
+ */
+File.setStatic(function from(obj) {
+
+	let path;
+
+	if (typeof obj == 'string') {
+		path = obj;
+		obj = null;
+	} else {
+		path = obj.path;
+	}
+
+	let file = new File(path);
+
+	if (obj) {
+		file.stat = {
+			size : obj.size
+		};
+
+		file.name = obj.name;
+		file.type = obj.type;
+		file.hash = obj.hash;
+	}
+
+	return file;
+});
+
+/**
+ * Read and return the contents
+ *
+ * @author   Jelle De Loecker   <jelle@develry.be>
+ * @since    1.1.0
+ * @version  1.1.8
+ */
+File.setMethod(function read(options) {
+
+	let pledge = new Pledge();
+
+	if (!options) {
+		options = {flag: 'r'};
+	} else if (!options.flag) {
+		options.flag = 'r';
+	}
+
+	fs.readFile(this.path, options, function done(err, data) {
+
+		if (err) {
+			return pledge.reject(err);
+		}
+
+		pledge.resolve(data);
+	});
+
+	return pledge;
+});
+
+/**
+ * Read and return the contents as a string
+ *
+ * @author   Jelle De Loecker   <jelle@develry.be>
+ * @since    1.1.0
+ * @version  1.1.0
+ */
+File.setMethod(function readString(encoding) {
+
+	if (!encoding) {
+		encoding = 'utf8';
+	}
+
+	return this.read({encoding: encoding});
 });

package/lib/class/migration.js

@@ -0,0 +1,138 @@
+const libpath = alchemy.use('path');
+
+/**
+ * Migrations
+ *
+ * @constructor
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.0
+ * @version  1.2.0
+ */
+const Migration = Function.inherits('Alchemy.Base', function Migration(document) {
+	this.document = document;
+});
+
+/**
+ * Start the necesary migrations
+ *
+ * @constructor
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.0
+ * @version  1.2.0
+ */
+Migration.setStatic(async function start() {
+
+	const AlchemyMigration = Model.get('AlchemyMigration');
+
+	console.log('Starting migration task...');
+
+	let dir = new Classes.Alchemy.Inode.Directory(libpath.resolve(PATH_APP, 'migrations'));
+
+	await dir.loadContents();
+
+	for (let entry of dir) {
+
+		let name = entry.name.beforeLast('.js');
+
+		if (!name) {
+			continue;
+		}
+
+		let crit = AlchemyMigration.find();
+		crit.where('name').equals(name);
+
+		let record = await AlchemyMigration.find('first', crit);
+
+		if (record) {
+			if (record.ended) {
+				console.log(' »» Migration "' + name + '" already finished on ' + record.ended.format('Y-m-d H:i'));
+			} else if (record.error) {
+				console.log(' »» Migration "' + name + '" failed with error: ' + record.error);
+				console.log('Migrations stopped');
+				return;
+			} else {
+				console.log(' »» Migration "' + name + '" has not yet finished!');
+				console.log('Migrations stopped');
+				return;
+			}
+
+			continue;
+		}
+
+		record = AlchemyMigration.createDocument();
+		record.name = name;
+		record.path = entry.path;
+
+		await record.save();
+
+		try {
+
+			console.log(' »» Starting migration "' + name + '"');
+
+			let migration = new Migration(record);
+
+			await Blast.require(entry.path, {
+				client: false,
+				async : true,
+				arguments: {
+					names  : [
+						'Blast',
+						'Collection',
+						'Bound',
+						'Obj',
+						'Fn',
+						'migration'
+					],
+					values : [
+						Blast,
+						Blast.Collection,
+						Blast.Bound,
+						Blast.Bound.Object,
+						Blast.Collection.Function,
+						migration,
+					]
+				}
+			});
+
+			record.ended = new Date();
+			await record.save();
+
+		} catch (err) {
+			console.log(' »» Migration error:', err);
+			record.error = err.message + '\n' + err.stack;
+			await record.save();
+			console.log('Migrations stopped');
+			return;
+		}
+	}
+
+	console.log('Executed all migrations');
+});
+
+/**
+ * Migrate methods
+ *
+ * @constructor
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.2.0
+ * @version  1.2.0
+ */
+Migration.setMethod(function processRecords(model_name, fnc) {
+
+	const model = Model.get(model_name);
+
+	let options = {
+		document       : false,
+		parallel_limit : 1,
+	};
+
+	return model.eachRecord(options, async (record, index, next) => {
+		await fnc(model, record[model_name], index);
+		next();
+	}, (err) => {
+		// Done!
+	});
+});