alchemymvc 1.2.8 → 1.3.0

package/lib/class/conduit.js

@@ -1,7 +1,8 @@
-var fileCache  = alchemy.shared('files.fileCache'),
-    libstream  = alchemy.use('stream'),
+const FILECACHE = alchemy.getCache('served_files'),
+      RX_TEXT = /svg|xml|javascript|text/i;
+
+var libstream  = alchemy.use('stream'),
     libpath = alchemy.use('path'),
-    libmime = alchemy.use('mime'),
     libua   = alchemy.use('useragent'),
     zlib    = alchemy.use('zlib'),
     BODY    = Symbol('body'),
@@ -345,7 +346,7 @@ Conduit.setMethod(function setRequestFiles(files) {
  *
  * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    1.2.0
- * @version  1.2.0
+ * @version  1.3.0
  *
  * @param    {Conduit}   conduit
  * @param    {Array}     files
@@ -370,7 +371,7 @@ function _setRequestFiles(conduit, files, target) {
 
 			_setRequestFiles(conduit, entry, context);
 		} else {
-			target[key] = Classes.Alchemy.Inode.File.from(entry);
+			target[key] = Classes.Alchemy.Inode.File.fromUntrusted(entry);
 		}
 	}
 }
@@ -980,7 +981,7 @@ Conduit.setMethod(function getRouteByName(name) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.7
+ * @version  1.3.0
  *
  * @param    {Route}   after_route   Only check routes after this one
  *
@@ -1009,7 +1010,7 @@ Conduit.setMethod(async function parseRoute(after_route) {
 
 		if (temp) {
 			this.route = temp.route;
-			this.params = temp.parameters;
+			this.setRouteParameters(temp.parameters);
 			this.route_string_parameters = temp.original_parameters;
 			this.path_definition = temp.definition;
 		} else {
@@ -1048,11 +1049,11 @@ Conduit.setMethod(async function parseRoute(after_route) {
 		}
 
 		if (temp) {
-			this.params = temp.parameters || {};
+			this.setRouteParameters(temp.parameters);
 			this.route_string_parameters = temp.original_parameters || {};
 			this.path_definition = temp.definition;
 		} else {
-			this.params = {};
+			this.setRouteParameters();
 		}
 	}
 });
@@ -1287,20 +1288,46 @@ Conduit.setMethod(function postpone(options) {
 /**
  * Set the response url
  *
+ * @deprecated   Use {@link #setResponseUrl} instead
+ *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    1.2.5
- * @version  1.2.5
+ * @version  1.3.0
  *
  * @param    {String|RURL}   url
  */
 Conduit.setMethod(function overrideResponseUrl(url) {
+	return this.setResponseUrl(url);
+});
 
-	if (typeof url != 'string') {
-		url = String(url);
+/**
+ * Set the response url
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {String|RURL|Boolean}   new_url
+ */
+Conduit.setMethod(function setResponseUrl(new_url) {
+
+	if (new_url == null) {
+		return;
+	}
+
+	if (!new_url) {
+		this.renderer.history = false;
+		return;
+	} else {
+		this.renderer.history = true;
 	}
 
-	this.setHeader('x-history-url', url);
-	this.expose('redirected_to', url);
+	if (typeof new_url != 'string') {
+		new_url = String(new_url);
+	}
+
+	this.setHeader('x-history-url', new_url);
+	this.expose('redirected_to', new_url);
 });
 
 /**
@@ -1583,9 +1610,9 @@ Conduit.setMethod(function notModified() {
 /**
  * Respond with text. Objects get JSON-dry encoded
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.0
  *
  * @param    {String|Object}   message
  */
@@ -1659,7 +1686,7 @@ Conduit.setMethod(function end(message) {
 
 	// Compress the output if the client accepts it,
 	// but only if the file is at least 150 bytes
-	if (alchemy.settings.compression && message.length > 150 && this.accepts('gzip')) {
+	if (alchemy.settings.compression !== false && message.length > 150 && this.accepts('gzip')) {
 
 		// Set the decompressed content-length for use in progress bars
 		this.setHeader('x-decompressed-content-length', Buffer.byteLength(message));
@@ -1865,287 +1892,229 @@ function bufferToStream(buffer) {
 }
 
 /**
- * Send a file to the browser.
- * Uses cache-control by default.
+ * Send a file to the browser
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.0
  *
  * @param    {String}   path      The path on the server to send to the browser
  * @param    {Object}   options   Options, including headers
  */
-Conduit.setMethod(function serveFile(path, options) {
+Conduit.setTypedMethod([Types.String, Types.Object.optional()], function serveFile(path, options = {}) {
 
-	var that = this,
-	    tasks = [],
-	    stats,
-	    isStream;
-
-	// Create an options object if it doesn't exist yet
-	if (options == null) {
-		options = {};
-	}
+	let file = FILECACHE.get(path);
 
-	// Error handling function
-	if (!options.onError) {
-		options.onError = function onError(err) {
-			that.notFound(err);
-		};
+	if (!file) {
+		file = new Classes.Alchemy.Inode.File(path);
 	}
 
-	// See if we have a stats object
-	if (Object.isObject(path)) {
-
-		if (Buffer.isBuffer(path)) {
-			path = bufferToStream(path);
-		}
+	return this.serveFile(file, options);
+});
 
-		if (path.readable) {
-			isStream = true;
-			stats = {
-				mimetype: 'application/octet-stream'
-			};
-		} else {
-			stats = path;
-		}
-	} else {
-		stats = fileCache[path];
+/**
+ * Send a file to the browser
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    0.2.0
+ * @version  1.3.0
+ *
+ * @param    {Alchemy.Inode.File}   file      The file to serve
+ * @param    {Object}               options   Options, including headers
+ */
+Conduit.setTypedMethod([Types.Alchemy.Inode.File, Types.Object.optional()], async function serveFile(file, options = {}) {
 
-		if (stats == null) {
-			stats = {
-				path: path
-			};
-		}
+	if (file.path && !FILECACHE.has(file.path)) {
+		FILECACHE.set(file.path, file);
+	}
+	
+	if (alchemy.settings.cache && (!options.cache_time && options.cache_time !== false)) {
+		let stats = await file.getStats();
+		options.cache_time = stats.mtime;
 	}
 
-	// Don't check for file information when it's a stream
-	if (!isStream) {
-
-		if (!stats.path) {
-			return options.onError(new Error('No file to serve'));
-		}
-
-		// Make sure the stats object is in the cache
-		if (fileCache[stats.path] == null) {
-			fileCache[stats.path] = stats;
-		}
-
-		// Get file stats if it isn't available yet
-		if (stats.mtime == null) {
-			tasks.push(function getFileStats(next) {
-
-				fs.stat(stats.path, function gotStats(err, fileStats) {
-
-					if (err) {
-						stats.err = err;
-						stats.mtime = new Date();
-					} else {
-						Object.assign(stats, fileStats);
-					}
-
-					next();
-				});
-			});
-		}
-
-		// Get the mimetype if it isn't available yet
-		if (!options.mimetype && stats.mimetype == null) {
-			tasks.push(function getMimetype(next) {
-
-				// Don't use libmime if it isn't loaded,
-				// that could be the case on NW.js
-				if (!libmime) {
-					return next();
-				}
-
-				// Lookup the mimetype by the extension alone
-				stats.mimetype = libmime.getType(stats.path);
-
-				// Return the result if a valid mimetype was found
-				if (stats.mimetype !== 'application/octet-stream') {
-					return next();
-				}
+	if (!options.mimetype) {
+		options.mimetype = await file.getMimetype();
+	}
 
-				// If no mimetype was found,
-				// see if we can find it using the original path (for resized images)
-				if (options.original_path) {
-					stats.mimetype = libmime.getType(options.original_path);
+	if (!options.filename) {
+		options.filename = file.name;
+	}
+	
+	return this.serveFile(file.createReadStream(), options);
+});
 
-					if (stats.mimetype !== 'application/octet-stream') {
-						return next();
-					}
-				}
+/**
+ * Send a buffer to the client
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {Stream}   buffer    The buffer to send
+ * @param    {Object}   options   Options, including headers
+ */
+Conduit.setTypedMethod([Buffer, Types.Object.optional()], function serveFile(buffer, options = {}) {
+	return this.serveFile(bufferToStream(buffer), options);
+});
 
-				// "magic" currently doesn't work in nw.js
-				if (Blast.isNW) {
-					return next();
-				}
+/**
+ * Send a stream to the client
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {Stream}   stream    The stream to send
+ * @param    {Object}   options   Options, including headers
+ */
+Conduit.setTypedMethod([Types.Stream, Types.Object.optional()], function serveFile(stream, options = {}) {
 
-				// Don't try to use magic if it's not loaded
-				if (!getMagic()) {
-					return next();
-				}
+	let is_text = false;
 
-				// Look inside the data (using "magic") for a better mimetype
-				magic.detectFile(stats.path, function detectedMimetype(err, result) {
+	if (options.mimetype && RX_TEXT.test(options.mimetype)) {
+		options.mimetype += '; charset=utf-8';
+		is_text = true;
+	}
 
-					if (!err) {
-						stats.mimetype = result;
-					}
+	if (alchemy.settings.cache === false) {
+		options.cache_time = null;
+	}
 
-					next();
-				});
-			});
-		}
+	if (options.compress == null) {
+		options.compress = is_text;
 	}
 
-	Function.parallel(tasks, function gotFileInfo(err) {
+	if (options.compress && (alchemy.settings.compression === false || !this.accepts('gzip'))) {
+		options.compress = false;
+	}
 
-		var disposition,
-		    outStream,
-		    mimetype,
-		    headers,
-		    isText,
-		    since,
-		    key;
+	if (options.cache_time && !alchemy.settings.cache) {
+		options.cache_time = false;
+	}
 
-		if (err) {
-			return that.error(err);
-		}
+	if (!options.onError) {
+		options.onError = err => this.notFound(err);
+	}
 
-		if (stats.err) {
-			return options.onError(stats.err);
-		}
+	return this._sendStream(stream, options);
+});
 
-		if (!isStream && !stats.path) {
-			return options.onError(new Error('File not found'));
-		}
+/**
+ * Send a stream to the client
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ *
+ * @param    {Stream}   stream    The stream to send
+ * @param    {Object}   options   Options, including headers
+ */
+Conduit.setMethod(function _sendStream(stream, options) {
 
-		// Check the if-modified-since header if it's supplied
-		if (alchemy.settings.cache !== false && that.headers['if-modified-since'] != null) {
+	if (options.cache_time) {
+		let modified_since = this.headers['if-modified-since'];
 
-			// Turn the string into a date
-			since = new Date(that.headers['if-modified-since']);
+		if (modified_since != null) {
+			let since = new Date(modified_since);
 
 			// If the file's modifytime is smaller or equal to the since time,
 			// don't serve the contents!
-			if (stats.mtime <= since) {
-				return that.notModified();
-			}
-		}
-
-		mimetype = stats.mimetype;
-
-		// If we get a general mimetype, and an alternative is provided, use that one
-		if (!mimetype || mimetype === 'application/octet-stream') {
-			if (options.mimetype != null) {
-				mimetype = options.mimetype;
+			if (options.cache_time <= since) {
+				return this.notModified();
 			}
 		}
 
-		isText = /svg|xml|javascript|text/.test(mimetype);
-
-		// Serve text files as utf-8
-		if (isText) {
-			mimetype += '; charset=utf-8';
-		}
-
-		that.setHeader('content-type', mimetype);
-
-		// Setting the disposition makes the browser download the file
-		// This is on by default, but can be disabled
-		if (options.disposition == 'inline') {
-			disposition = 'inline';
-
-			if (options.filename) {
-				disposition += '; filename=' + JSON.stringify(options.filename)
-			}
-
-			that.setHeader('content-disposition', disposition);
-		} else if (options.disposition !== false) {
-			if (options.filename) {
-				disposition = 'attachment; filename=' + JSON.stringify(options.filename);
-			} else {
-				disposition = 'attachment';
-			}
+		// Allow the browser to cache this for 60 minutes,
+		// after which it has to revalidate the content
+		// by seeing if it has been modified
+		this.setHeader('cache-control', 'public, max-age=3600, must-revalidate');
+		this.setHeader('last-modified', options.cache_time.toGMTString());
+	} else {
+		this.setHeader('cache-control', 'no-cache');
+	}
 
-			that.setHeader('content-disposition', disposition);
-		}
+	let disposition,
+	    key;
 
-		if (stats.mtime && alchemy.settings.cache) {
-			// Allow the browser to cache this for 60 minutes,
-			// after which it has to revalidate the content
-			// by seeing if it has been modified
-			that.setHeader('cache-control', 'public, max-age=3600, must-revalidate');
-			that.setHeader('last-modified', stats.mtime.toGMTString());
-		} else if (!alchemy.settings.cache) {
-			that.setHeader('cache-control', 'no-cache');
-		}
+	if (options.mimetype) {
+		this.setHeader('content-type', options.mimetype);
+	}
 
-		for (key in options.headers) {
-			that.setHeader(key, options.headers[key]);
-		}
+	// Setting the disposition makes the browser download the file
+	// This is on by default, but can be disabled
+	if (options.disposition == 'inline') {
+		disposition = 'inline';
 
-		// End now if it's just a HEAD request
-		if (that.method == 'head') {
-			return that.end();
+		if (options.filename) {
+			disposition += '; filename=' + JSON.stringify(options.filename)
 		}
 
-		if (isStream) {
-			outStream = path;
+		this.setHeader('content-disposition', disposition);
+	} else if (options.disposition !== false) {
+		if (options.filename) {
+			disposition = 'attachment; filename=' + JSON.stringify(options.filename);
 		} else {
-			outStream = fs.createReadStream(path, {bufferSize: 64*1024});
-
-			// Listen for file errors
-			outStream.on('error', options.onError);
+			disposition = 'attachment';
 		}
 
-		// Compress text responses
-		if (isText && alchemy.settings.compression && that.accepts('gzip')) {
+		this.setHeader('content-disposition', disposition);
+	}
 
-			// Set the gzip header
-			that.setHeader('content-encoding', 'gzip');
-			that.setHeader('vary', 'accept-encoding');
+	// Set all the headers
+	for (key in options.headers) {
+		this.setHeader(key, options.headers[key]);
+	}
 
-			// Create the gzip stream
-			outStream = outStream.pipe(zlib.createGzip());
-		}
+	// Don't send anything if it's a HEAD request
+	if (this.method == 'head') {
+		return this.end();
+	}
 
-		// If we received a stream as parameter...
-		if (isStream) {
-			that.response.on('end', cleanup);
-			that.response.on('finish', cleanup);
-			that.response.on('error', cleanup);
-			that.response.on('close', cleanup);
-		}
+	const response = this.response;
+	let out_stream = stream;
+
+	if (options.compress) {
+		// Set the gzip header
+		this.setHeader('content-encoding', 'gzip');
+		this.setHeader('vary', 'accept-encoding');
 
-		function cleanup() {
+		// Create the gzip stream
+		out_stream = out_stream.pipe(zlib.createGzip());
+	}
 
+	if (options.cleanup_stream) {
+		const cleanup = function cleanupOriginalStream() {
 			// Remove all pipes
-			outStream.unpipe();
+			stream.unpipe();
 
-			if (outStream.destroy) {
-				outStream.destroy();
-			} else if (outStream.end) {
-				outStream.end();
+			if (stream.destroy) {
+				stream.destroy();
+			} else if (stream.end) {
+				stream.end();
 			}
-		}
+		};
 
-		// Send the headers
-		for (key in that.response_headers) {
-			that.response.setHeader(key, that.response_headers[key]);
-		}
+		response.on('end', cleanup);
+		response.on('finish', cleanup);
+		response.on('error', cleanup);
+		response.on('close', cleanup);
+	}
 
-		if (that.new_cookie_header.length) {
-			that.response.setHeader('set-cookie', that.new_cookie_header);
-		}
+	// Set the response headers
+	for (key in this.response_headers) {
+		response.setHeader(key, this.response_headers[key]);
+	}
 
-		that.response.statusCode = 200;
+	if (this.new_cookie_header.length) {
+		response.setHeader('set-cookie', this.new_cookie_header);
+	}
 
-		// Stream the file to the client
-		outStream.pipe(that.response);
-	});
+	// If we got this far, the file has been found!
+	response.statusCode = 200;
+
+	// Actually stream the contents to the client
+	out_stream.pipe(response);
 });
 
 /**
@@ -2307,6 +2276,24 @@ Conduit.setMethod(function routeParam(name) {
 	return this.params[name];
 });
 
+/**
+ * Set route parameters
+ *
+ * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @since    1.3.0
+ * @version  1.3.0
+ */
+Conduit.setMethod(function setRouteParameters(data) {
+
+	if (!this.params) {
+		this.params = {};
+	}
+
+	if (data) {
+		Object.assign(this.params, data);
+	}
+});
+
 /**
  * Get/set a cookie
  *
@@ -2370,7 +2357,7 @@ Conduit.setMethod(function cookie(name, value, options) {
  *
  * @author   Jelle De Loecker   <jelle@develry.be>
  * @since    0.2.0
- * @version  1.1.0
+ * @version  1.3.0
  *
  * @param    {String}   name
  * @param    {Mixed}    value
@@ -2382,7 +2369,7 @@ Conduit.setMethod(function setHeader(name, value) {
 	}
 
 	if (this.websocket) {
-		throw new Error("Can't set a header on a websocket connection");
+		throw new Error("Can't set header `" + name + "` on a websocket connection");
 	}
 
 	this.response_headers[name] = value;

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.2.0
+ * @version  1.3.0
  *
  * @param    {Schema|Model}   schema
  * @param    {Object}         data
@@ -187,7 +187,11 @@ Datasource.setMethod(function toDatasource(schema, data, callback) {
 	}
 
 	if (!schema) {
-		log.todo('Schema not found: not normalizing data', data);
+
+		if (alchemy.settings.debug) {
+			log.todo('Schema not found: not normalizing data', data);
+		}
+
 		pledge = Pledge.resolve(data);
 		pledge.done(callback);
 		return pledge;

package/lib/class/document.js

@@ -647,7 +647,7 @@ Document.setMethod(['populate', 'addAssociatedData'], function addAssociatedData
  *
  * @author   Jelle De Loecker <jelle@develry.be>
  * @since    0.3.0
- * @version  0.3.0
+ * @version  1.3.0
  *
  * @param    {Object}   options
  *
@@ -663,7 +663,7 @@ Document.setMethod(function getDisplayFieldValue(options) {
 		options = {};
 	}
 
-	display_field = Array.cast(this.$model.displayField);
+	display_field = Array.cast(this.$model.display_field);
 
 	// If there are fields we prefer, check those first
 	if (options.prefer) {
@@ -674,7 +674,7 @@ Document.setMethod(function getDisplayFieldValue(options) {
 		result = this[display_field[i]];
 
 		if (result) {
-			result = alchemy.pickTranslation(undefined, result).result;
+			result = alchemy.pickTranslation(options.prefix, result).result;
 
 			if (result) {
 				return result;