alchemymvc 1.4.0-alpha.6 → 1.4.0-alpha.8

package/lib/app/helper_model/model.js

@@ -680,6 +680,11 @@ Model.setMethod(function getAliasModel(alias) {
 		config = this.schema.associations[alias];
 	}
 
+	// @TODO: associated fields with an alias name inside a nested schema
+	// somehow breaks! Should be looked in to?
+	// Workaround: set `recursive: 0` on the root schema field
+	// console.log('Alias:', alias, 'config:', config, this.schema);
+
 	if (config) {
 		result = this.getModel(config.modelName);
 	} else {

package/lib/app/model/system_setting_model.js

@@ -144,11 +144,19 @@ SystemSetting.setDocumentMethod(function applySetting(do_actions = true) {
 
 	if (!existing_value) {
 		existing_value = setting.generateValue();
+		alchemy.system_settings.forceValueInstanceAtPath(this.setting_id, existing_value);
 	}
 
+	let result;
+
 	if (do_actions) {
-		return existing_value.setValue(this.configuration.value);
+		result = existing_value.setValue(this.configuration.value);
 	} else {
-		return existing_value.setValueSilently(this.configuration.value);
+		result = existing_value.setValueSilently(this.configuration.value);
 	}
+
+	// And now force the settings to update!
+	alchemy.refreshSettingsObject();
+
+	return result;
 });

package/lib/core/alchemy.js

@@ -17,7 +17,7 @@ let shared_objects = {},
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    0.0.1
- * @version  1.3.21
+ * @version  1.4.0
  */
 global.Alchemy = Function.inherits('Alchemy.Base', function Alchemy() {
 
@@ -147,7 +147,6 @@ global.Alchemy = Function.inherits('Alchemy.Base', function Alchemy() {
 	this.text_body = this.use('body');
 	this.formidable = this.use('formidable');
 	this.body_parser = this.use('body-parser');
-	this.url_form_body = this.body_parser.urlencoded({extended: true});
 });
 
 /**
@@ -581,10 +580,21 @@ Alchemy.setMethod(function setSetting(path, value) {
 	this.system_settings.setPathSilently(path, value);
 
 	if (this.started) {
-		this.settings = this.system_settings.toObject();
+		this.refreshSettingsObject();
 	}
 });
 
+/**
+ * Refresh the settings object
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ */
+Alchemy.setMethod(function refreshSettingsObject() {
+	this.settings = this.system_settings.toObject();
+});
+
 /**
  * Get a setting value
  *
@@ -1745,12 +1755,43 @@ Alchemy.setMethod(function addAppcacheEntry(entry) {
 	ac_entries[entry.type].push(entry);
 });
 
+/**
+ * Get a size limit for the given route
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {Route?}   route
+ * @param    {string}   name
+ */
+function getRouteSizeLimit(route, name) {
+
+	let global_size = alchemy.settings.network[name];
+
+	if (!route) {
+		return global_size;
+	}
+
+	let route_value = route.options[name];
+
+	if (route_value == null || typeof route_value != 'number') {
+		return global_size;
+	}
+
+	if (route_value <= 0) {
+		return Infinity;
+	}
+
+	return route_value;
+}
+
 /**
  * Get the body of an IncomingMessage
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.1.0
- * @version  1.3.18
+ * @version  1.4.0
  *
  * @param    {IncomingMessage}   req
  * @param    {OutgoingMessage}   res       Optional
@@ -1777,24 +1818,44 @@ Alchemy.setMethod(function parseRequestBody(req, res, callback) {
 
 	let content_type = req.headers['content-type'];
 
+	let request_body_size_limit = getRouteSizeLimit(conduit?.route, 'request_body_size_limit');
+
 	// Multipart data is handled by "formidable"
 	if (content_type && content_type.startsWith('multipart/form-data')) {
 
+		let request_individual_file_size_limit = getRouteSizeLimit(conduit?.route, 'request_individual_file_size_limit'),
+		    request_total_file_size_limit = getRouteSizeLimit(conduit?.route, 'request_total_file_size_limit');
+
 		let form = new this.formidable.IncomingForm({
 			multiples     : true,
 			hashAlgorithm : this.settings.data_management.file_hash_algorithm || 'sha1',
+			minFileSize      : 0,
+			allowEmptyFiles  : true,
+			maxFileSize      : request_individual_file_size_limit,
+			maxFieldsSize    : request_body_size_limit,
+			maxTotalFileSize : request_total_file_size_limit,
 		});
 
 		form.parse(req, function parsedMultipart(err, form_fields, form_files) {
 
-			var fields = {},
-			    files = {},
-			    key;
+			if (err) {
+
+				// Ignore the error if the request was already aborted
+				if (conduit?.aborted) {
+					return callback(null);
+				}
 
-			if (err && req.conduit && req.conduit.aborted) {
-				return callback(null);
+				if (conduit) {
+					return conduit.error(err);
+				}
+
+				return callback(err);
 			}
 
+			let fields = {},
+			    files = {},
+			    key;
+
 			// Since formidable v3, all the fields are now arrays.
 			// We already had a lot of logic to deal with this,
 			// so we just have to un-array everything
@@ -1811,18 +1872,12 @@ Alchemy.setMethod(function parseRequestBody(req, res, callback) {
 				Object.setFormPath(files, key, form_files[key]);
 			}
 
-			if (err) {
-				log.error('Error parsing multipart POST', {err: err});
-				req.body = {};
-				req.files = {};
-			} else {
-				req.body = fields;
-				req.files = files;
+			req.body = fields;
+			req.files = files;
 
-				if (conduit) {
-					conduit.setRequestBody(fields);
-					conduit.setRequestFiles(files);
-				}
+			if (conduit) {
+				conduit.setRequestBody(fields);
+				conduit.setRequestFiles(files);
 			}
 
 			callback(null, fields);
@@ -1834,24 +1889,34 @@ Alchemy.setMethod(function parseRequestBody(req, res, callback) {
 	// Regular form-encoded data
 	if (content_type && content_type.indexOf('form-urlencoded') > -1) {
 
-		this.url_form_body(req, res, function parsedBody(err) {
+		let url_form_body = this.body_parser.urlencoded({
+			limit: request_body_size_limit,
+			extended: true,
+		});
 
-			if (err && req.conduit && req.conduit.aborted) {
-				return callback(null);
+		url_form_body(req, res, function parsedBody(err) {
+
+			if (err) {
+
+				// Ignore the error if the request was already aborted
+				if (conduit?.aborted) {
+					return callback(null);
+				}
+
+				if (conduit) {
+					return conduit.error(err);
+				}
+
+				return callback(err);
 			}
 
 			// You can't send files using a regular post
 			req.files = {};
 
-			if (err) {
-				log.error('Error parsing x-www-form-urlencoded body data', {err: err});
-				req.body = {};
-			} else {
-				req.body = req.body;
+			req.body = req.body;
 
-				if (conduit) {
-					conduit.setRequestBody(req.body);
-				}
+			if (conduit) {
+				conduit.setRequestBody(req.body);
 			}
 
 			callback(null, req.body);
@@ -1861,25 +1926,30 @@ Alchemy.setMethod(function parseRequestBody(req, res, callback) {
 	}
 
 	// Any other encoded data (like JSON)
-	this.any_body(req, function parsedBody(err, body) {
+	this.any_body(req, res, {limit: request_body_size_limit}, function parsedBody(err, body) {
 
 		function handleResponse(err, body) {
-			if (err && req.conduit && req.conduit.aborted) {
-				return callback(null);
+
+			if (err) {
+
+				// Ignore the error if the request was already aborted
+				if (conduit?.aborted) {
+					return callback(null);
+				}
+
+				if (conduit) {
+					return conduit.error(err);
+				}
+
+				return callback(err);
 			}
-	
+
 			// You can't send files using a regular post
 			req.files = {};
+			req.body = body;
 	
-			if (err) {
-				log.error('Error parsing body data', {err: err});
-				req.body = {};
-			} else {
-				req.body = body;
-	
-				if (conduit) {
-					conduit.setRequestBody(body);
-				}
+			if (conduit) {
+				conduit.setRequestBody(body);
 			}
 	
 			callback(null, req.body);

package/lib/core/alchemy_functions.js

@@ -1,6 +1,7 @@
 let mkdirp       = alchemy.use('mkdirp')?.mkdirp,
     ncp          = alchemy.use('ncp').ncp,
     fs           = alchemy.use('fs'),
+    fsp          = fs.promises,
     libpath      = alchemy.use('path'),
     child        = alchemy.use('child_process'),
     crypto       = alchemy.use('crypto'),
@@ -1106,6 +1107,53 @@ Alchemy.setMethod(function request(url, options, callback) {
 	return Blast.fetch(options, callback);
 });
 
+/**
+ * Turn a `data:` uri into a file
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {string}   data_uri
+ *
+ * @return   {Pledge<File>}
+ */
+function convertDataUriToFile(data_uri) {
+
+	// Split the data uri into its 2 parts
+	let pieces = data_uri.slice(5).split(',');
+
+	// Split the info bit
+	let info = pieces[0].split(';');
+
+	// Get the expected mime type
+	let mime_type = info[0];
+
+	// And is it base64?
+	let is_b64 = info[1] && info[1].toLowerCase() == 'base64';
+
+	let buffer;
+
+	if (is_b64) {
+		buffer = Buffer.from(pieces[1], 'base64');
+	} else {
+		buffer = Buffer.from(String.decodeURI(pieces[1]));
+	}
+
+	return Pledge.Swift.waterfall(
+		() => Blast.createTempDir({prefix: 'aldl'}),
+		async (temp_dir) => {
+			let full_path = libpath.resolve(temp_dir, 'buffer_' + alchemy.ObjectId());
+			
+			await fsp.writeFile(full_path, buffer);
+
+			return full_path;
+		},
+		(full_path) => Classes.Alchemy.Inode.Inode.from(full_path)
+	);
+
+}
+
 /**
  * Download a file
  *
@@ -1119,6 +1167,14 @@ Alchemy.setMethod(function request(url, options, callback) {
  */
 Alchemy.setMethod(function download(url, options) {
 
+	if (url.startsWith('data:')) {
+		try {
+			return convertDataUriToFile(url, options);
+		} catch (err) {
+			return Pledge.reject(err);
+		}
+	}
+
 	const pledge = new Pledge();
 
 	// Get the file

package/lib/core/base.js

@@ -564,7 +564,7 @@ Base.setMethod(function attachConduit(conduit) {
  *
  * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    0.3.0
- * @version  1.1.8
+ * @version  1.4.0
  *
  * @param    {string}   name      The name of the model to get
  * @param    {boolean}  init      Initialize the class [true]
@@ -597,9 +597,9 @@ Base.setMethod(function getModel(name, init, options) {
 
 	if (options.cache !== false) {
 		if (!this._modelInstances) {
-			this._modelInstances = {};
+			this._modelInstances = new Map();
 		} else {
-			instance = this._modelInstances[name];
+			instance = this._modelInstances.get(name);
 		}
 	}
 
@@ -622,7 +622,7 @@ Base.setMethod(function getModel(name, init, options) {
 	}
 
 	if (options.cache !== false) {
-		this._modelInstances[name] = instance;
+		this._modelInstances.set(name, instance);
 	}
 
 	return instance;

package/lib/core/setting.js

@@ -452,6 +452,9 @@ const Group = Function.inherits('Alchemy.Setting.Base', function Group(name, con
 
 	// All the children
 	this.children = new Map();
+
+	// Weak references to existing values
+	this.weak_values = new Blast.Classes.WeakValueSet();
 });
 
 /**
@@ -583,6 +586,14 @@ Group.setMethod(function createGroup(name) {
 	let group = new Group(name, this);
 	this.children.set(name, group);
 
+	if (this.weak_values.size) {
+		let group_value = group.generateValue();
+
+		for (let existing of this.weak_values) {
+			this.setDefaultValue(existing, {[name]: group_value});
+		}
+	}
+
 	return group;
 });
 
@@ -633,6 +644,8 @@ Group.setMethod(function generateValue() {
 
 	this.setDefaultValue(result, object);
 
+	this.weak_values.add(result);
+
 	return result;
 });
 
@@ -1344,6 +1357,38 @@ GroupValue.setMethod(function _setPath(silent, path, raw_value) {
 	return this.getPath(path);
 });
 
+/**
+ * Force a value at the given path
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {string|Array}   path
+ * @param    {Value}
+ */
+GroupValue.setMethod(function forceValueInstanceAtPath(path, value) {
+
+	if (typeof path == 'string') {
+		path = path.split('.');
+	}
+
+	if (this.definition.group == null && path[0] == this.definition.name) {
+		path.shift();
+	}
+
+	let last = path.pop();
+
+	let current = this;
+
+	while (path.length && current) {
+		let next = path.shift();
+		current = current.get(next);
+	}
+
+	current[VALUE][last] = value;
+});
+
 /**
  * Convert to a datasource array
  *
@@ -1584,6 +1629,20 @@ Value.setMethod(function getPath(path) {
 	return current;
 });
 
+/**
+ * Force a value at the given path
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {string|Array}   path
+ * @param    {Value}
+ */
+Value.setMethod(function forceValueInstanceAtPath(path, value) {
+	throw new Error('Unable to perform on a simple Value instance');
+});
+
 if (Blast.isBrowser) {
 	return;
 }
@@ -1675,15 +1734,61 @@ const MagicGroupValue = Function.inherits('Magic', 'Alchemy.Setting', function M
  */
 MagicGroupValue.setMethod(function __get(key) {
 
-	let result = this[VALUE].get(key);
+	let result = this[key];
+
+	if (result != null) {
+		return result;
+	}
+
+	result = this[VALUE].get(key);
+
+	if (result == null) {
+		return this[VALUE][key];
+	}
 
 	if (!result) {
-		return;
+		return result;
 	}
 
 	if (result.is_group) {
 		return result.toProxyObject();
 	}
 
+	if (!result.get) {
+		return result;
+	}
+
 	return result.get();
+});
+
+/**
+ * The magic getter
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {string}   key
+ */
+MagicGroupValue.setMethod(function __ownKeys() {
+	return Object.keys(this[VALUE].toObject())
+});
+
+/**
+ * The magic getter
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {string}   key
+ */
+MagicGroupValue.setMethod(function __describe(key) {
+	let result = Object.getOwnPropertyDescriptor(this[VALUE], key);
+
+	if (result == null) {
+		result = Object.getOwnPropertyDescriptor(this, key);
+	}
+
+	return result;
 });

package/lib/scripts/create_settings.js

@@ -73,6 +73,24 @@ network.addSetting('use_compression', {
 	description : 'Compress responses using gzip/deflate',
 });
 
+network.addSetting('request_body_size_limit', {
+	type        : 'number',
+	default     : 20 * 1024 * 1024,
+	description : 'Maximum allowed size in bytes for the request body, excluding files',
+});
+
+network.addSetting('request_individual_file_size_limit', {
+	type        : 'number',
+	default     : 200 * 1024 * 1024,
+	description : 'Maximum allowed size in bytes for individual uploaded files',
+});
+
+network.addSetting('request_total_file_size_limit', {
+	type        : 'number',
+	default     : 200 * 1024 * 1024,
+	description : 'Maximum allowed size in bytes for all uploaded files',
+});
+
 network.addSetting('use_json_dry_responses', {
 	type        : 'boolean',
 	default     : true,

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "alchemymvc",
 	"description": "MVC framework for Node.js",
-	"version": "1.4.0-alpha.6",
+	"version": "1.4.0-alpha.8",
 	"author": "Jelle De Loecker <jelle@elevenways.be>",
 	"keywords": [
 		"alchemy",