alchemymvc 1.3.22 → 1.4.0-alpha.2

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

@@ -1,18 +1,16 @@
 /**
  * NoSQL Datasource
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.1.0
  * @version  1.1.0
  */
-var NoSQL = Function.inherits('Alchemy.Datasource', function Nosql(name, options) {
-	Nosql.super.call(this, name, options);
-});
+var NoSQL = Function.inherits('Alchemy.Datasource', 'Nosql');
 
 /**
  * All comparison functions
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -21,7 +19,7 @@ NoSQL.setStatic('comparisons', {});
 /**
  * All logical operator functions
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -30,7 +28,7 @@ NoSQL.setStatic('logical_operators', {});
 /**
  * Add comparison function
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -41,7 +39,7 @@ NoSQL.setStatic(function addComparison(fnc) {
 /**
  * Add logical operator function
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -52,7 +50,7 @@ NoSQL.setStatic(function addLogicalOperator(fnc) {
 /**
  * Lower than comparison
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -63,7 +61,7 @@ NoSQL.addComparison(function $lt(a, b) {
 /**
  * Lower than or equal comparison
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -74,7 +72,7 @@ NoSQL.addComparison(function $lte(a, b) {
 /**
  * Greater than comparison
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -85,7 +83,7 @@ NoSQL.addComparison(function $gt(a, b) {
 /**
  * Greater than or equal comparison
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -96,7 +94,7 @@ NoSQL.addComparison(function $gte(a, b) {
 /**
  * Not equal comparison
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -112,7 +110,7 @@ NoSQL.addComparison(function $ne(a, b) {
 /**
  * In comparison
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -136,7 +134,7 @@ NoSQL.addComparison(function $in(a, b) {
 /**
  * Not in comparison
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -147,7 +145,7 @@ NoSQL.addComparison(function $nin(a, b) {
 /**
  * Regex comparison
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -167,7 +165,7 @@ NoSQL.addComparison(function $regex(a, b) {
 /**
  * Exists comparison
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -187,7 +185,7 @@ NoSQL.addComparison(function $exists(value, exists) {
 /**
  * Array size comparison
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -207,7 +205,7 @@ NoSQL.addComparison(function $size(obj, value) {
 /**
  * Array elemMatch comparison
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -231,7 +229,7 @@ NoSQL.addComparison(function $elemMatch(obj, value) {
 /**
  * Match any of the subqueries
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -255,7 +253,7 @@ NoSQL.addLogicalOperator(function $or(obj, query) {
 /**
  * Match all of the subqueries
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -279,7 +277,7 @@ NoSQL.addLogicalOperator(function $and(obj, query) {
 /**
  * Inverted match of the query
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -290,7 +288,7 @@ NoSQL.addLogicalOperator(function $not(obj, query) {
 /**
  * Use a function to match
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  */
@@ -316,14 +314,14 @@ NoSQL.addLogicalOperator(function $where(obj, fnc) {
  * If the treatObjAsValue flag is set,
  * don't try to match every part separately, but the array as a whole.
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.6
  *
  * @param    {Object}   obj
  * @param    {Object}   query
  *
- * @return   {Boolean}
+ * @return   {boolean}
  */
 NoSQL.setStatic(function matchQueryPart(obj, query_key, query_value, treat_obj_as_value) {
 
@@ -422,14 +420,14 @@ NoSQL.setStatic(function matchQueryPart(obj, query_key, query_value, treat_obj_a
 /**
  * Tell if a given document matches a query
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  *
  * @param    {Object}   obj
  * @param    {Object}   query
  *
- * @return   {Boolean}
+ * @return   {boolean}
  */
 NoSQL.setStatic(function match(obj, query) {
 
@@ -471,11 +469,11 @@ NoSQL.setStatic(function match(obj, query) {
 /**
  * Parse a record path
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  *
- * @param    {String}   path
+ * @param    {string}   path
  *
  * @return   {Object}
  */
@@ -506,7 +504,7 @@ NoSQL.setStatic(function parseRecordPath(path) {
 /**
  * Get a value from object with dot notation
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  *
@@ -562,11 +560,11 @@ NoSQL.setStatic(function getDotValue(obj, path) {
 /**
  * Are 2 values comparable
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.0.0
  * @version  1.0.0
  *
- * @return   {Boolean}
+ * @return   {boolean}
  */
 NoSQL.setStatic(function areComparable(a, b) {
 
@@ -588,18 +586,72 @@ NoSQL.setStatic(function areComparable(a, b) {
 /**
  * Compile criteria into a MongoDB query object
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.1.0
- * @version  1.3.16
+ * @version  1.4.0
  *
- * @param    {Criteria}   criteria
- * @param    {Group}      group
+ * @param    {Criteria}   criteria   The criteria to convert
+ * @param    {Object}     context    The optional context (for Trail retrieval)
  *
  * @return   {Object}
  */
-NoSQL.setMethod(function compileCriteria(criteria, group) {
+NoSQL.setStatic(function convertCriteriaToConditions(criteria, context) {
+
+	let config = {
+		for_database: false,
+	};
+
+	return convertCriteriaToConditionsWithConfig(criteria, config, context);
+});
+
+/**
+ * Compile criteria into a MongoDB query object with the given configuration
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.1.0
+ * @version  1.4.0
+ *
+ * @param    {Criteria}   criteria   The criteria to convert
+ * @param    {Object}     config     Configuration flags
+ * @param    {Object}     context    The optional context
+ *
+ * @return   {Object}
+ */
+function convertCriteriaToConditionsWithConfig(criteria, config, context) {
+
+	if (context) {
+		if (!Object.isPlainObject(context) || !context.$0) {
+			context = {$0: context};
+		}
+	}
+
+	if (!config) {
+		config = {
+			for_database : false,
+		};
+	}
+
+	return convertCriteriaGroupToConditions(criteria, criteria.group, config, context);
+}
+
+/**
+ * Compile criteria into a MongoDB query object
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.1.0
+ * @version  1.4.0
+ *
+ * @param    {Criteria}   criteria   The criteria to convert
+ * @param    {Group}      group      The current group
+ * @param    {Object}     config     Configuration flags
+ * @param    {Object}     context    The optional context
+ *
+ * @return   {Object}
+ */
+function convertCriteriaGroupToConditions(criteria, group, config, context) {
 
-	var assoc_model,
+	let is_for_database = config?.for_database,
+	    assoc_model,
 	    aggregate,
 	    result = [],
 	    entry,
@@ -607,10 +659,6 @@ NoSQL.setMethod(function compileCriteria(criteria, group) {
 	    temp,
 	    i;
 
-	if (!group) {
-		group = criteria.group;
-	}
-
 	let getAggregate = () => {
 		if (!aggregate) {
 			aggregate = {
@@ -688,7 +736,7 @@ NoSQL.setMethod(function compileCriteria(criteria, group) {
 		}
 
 		if (entry.group_type) {
-			let compiled_group = this.compileCriteria(entry.criteria, entry),
+			let compiled_group = convertCriteriaGroupToConditions(entry.criteria, entry, config, context),
 			    obj = {};
 
 			if (compiled_group.$and) {
@@ -697,7 +745,7 @@ NoSQL.setMethod(function compileCriteria(criteria, group) {
 				// @TODO: this won't work
 				compiled_group = compiled_group.pipeline;
 			} else {
-				compiled_group = null;
+				compiled_group = Array.cast(compiled_group);
 			}
 
 			if (compiled_group) {
@@ -730,6 +778,13 @@ NoSQL.setMethod(function compileCriteria(criteria, group) {
 			for (let i = 0; i < entry.items.length; i++) {
 				item = entry.items[i];
 
+				if (context && item.value && typeof item.value == 'object') {
+					item = {
+						...item,
+						value : Classes.Develry.Placeholder.deepResolve(item.value, context),
+					};
+				}
+
 				// If the value is a RegExp, we might have to stringify the value
 				if (shouldStringify(entry, item) && RegExp.isRegExp(item.value)) {
 
@@ -765,7 +820,19 @@ NoSQL.setMethod(function compileCriteria(criteria, group) {
 				} else if (item.type == 'equals') {
 					obj = item.value;
 				} else if (item.type == 'contains') {
-					obj = RegExp.interpret(item.value);
+
+					let do_regexp_search = true;
+
+					if (entry.field) {
+						if (entry.field.is_array || entry.field.options?.type == 'HasAndBelongsToMany') {
+							do_regexp_search = false;
+							obj = item.value;
+						}
+					}
+
+					if (do_regexp_search) {
+						obj = RegExp.interpret(item.value);
+					}
 				} else if (item.type == 'in') {
 
 					// @TODO: This shouldn't be needed,
@@ -791,31 +858,35 @@ NoSQL.setMethod(function compileCriteria(criteria, group) {
 					}
 				} else if (item.type == 'isEmpty') {
 
-					let exists = false,
-					    comparator = '$eq';
+					if (is_for_database) {
+						let exists = false,
+						    comparator = '$eq';
 
-					if (item.value === false) {
-						exists = true;
-						comparator = '$ne';
-					}
+						if (item.value === false) {
+							exists = true;
+							comparator = '$ne';
+						}
 
-					let $or = [
-						{$exists: exists}
-					];
+						let $or = [
+							{$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) {
+							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) {
-						$or.push({[comparator]: ''});
-					}
+						if (entry.field.is_array) {
+							$or.push({[comparator]: []});
+						} else if (entry.field instanceof Classes.Alchemy.Field.String) {
+							$or.push({[comparator]: ''});
+						}
 
-					$or.push({[comparator]: null});
+						$or.push({[comparator]: null});
 
-					obj.$or = $or;
+						obj.$or = $or;
+					} else {
+						obj = {$isEmpty: item.value ?? true};
+					}
 				} else {
 					throw new Error('Unknown criteria expression: "' + item.type + '"');
 				}
@@ -825,7 +896,7 @@ NoSQL.setMethod(function compileCriteria(criteria, group) {
 
 				// Temporary fix to actually query translatable field contents
 				// (entry.field can be undefined if trying to query a path)
-				if (entry.field && entry.field.is_translatable) {
+				if (entry.field?.is_translatable) {
 
 					let prefix = criteria.options.locale,
 					    specific_prefix = !!prefix;
@@ -937,16 +1008,36 @@ NoSQL.setMethod(function compileCriteria(criteria, group) {
 	}
 
 	if (!result.length) {
-		return {};
+		result = {};
+	} else if (result.length === 1) {
+		result = result[0];
+	} else {
+		result = {$and: result};
 	}
 
-	return {$and: result};
+	return result;
+};
+
+/**
+ * Compile criteria into a MongoDB-compatible query object
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.1.0
+ * @version  1.4.0
+ *
+ * @param    {Criteria}   criteria
+ * @param    {Group}      group
+ *
+ * @return   {Object}
+ */
+NoSQL.setMethod(function compileCriteria(criteria, group) {
+	return convertCriteriaToConditionsWithConfig(criteria, {for_database: true}, group);
 });
 
 /**
  * Is the given item about a string field?
  *
- * @author   Jelle De Loecker   <jelle@elevenways.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.2.0
  * @version  1.2.0
  *
@@ -971,10 +1062,473 @@ function shouldStringify(entry, item) {
 	return false;
 }
 
+/**
+ * Compile an AQL string into a MongoDB-compatible query object
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {string}   query
+ *
+ * @return   {Object}
+ */
+NoSQL.setStatic(function convertAQLToConditions(query) {
+
+	let tokens = tokenizeAQL(query);
+
+	let conditions = convertAQLTokens(tokens, (name, operator, value, not) => {
+
+		switch (operator) {
+			case 'is':
+			case 'eq':
+			case '==':
+			case '=':
+				operator = '$eq';
+				break;
+
+			case 'ne':
+			case '!=':
+				operator = '$ne';
+				break;
+
+			case 'gt':
+			case '>':
+				operator = '$gt';
+				break;
+
+			case 'gte':
+			case '>=':
+				operator = '$gte';
+				break;
+
+			case 'lt':
+			case '<':
+				operator = '$lt';
+				break;
+
+			case 'lte':
+			case '<=':
+				operator = '$lte';
+				break;
+
+			case 'empty':
+				operator = '$isEmpty';
+				value = {value: !not};
+				break;
+		}
+
+		switch (value.type) {
+			case 'name':
+				value = Trail.fromDot(value.value);
+				break;
+			
+			case 'number':
+				value = Number(value.value);
+				break;
+
+			case 'boolean':
+				value = value.value == 'true';
+				break;
+			
+			case 'string':
+				value = String.parseQuoted(value.value);
+				break;
+			
+			default:
+				value = value.value;
+				break;
+		}
+
+		let result = {
+			[name]: {
+				[operator]: value,
+			}
+		};
+
+		return result;
+	});
+
+	return conditions;
+});
+
+/**
+ * Parse the AQL query into tokens
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {string}   query
+ *
+ * @return   {Array}
+ */
+function tokenizeAQL(query) {
+
+	const START_STATE = 1,
+	      NAME_STATE = 2,
+	      OPERATOR_STATE = 3,
+	      VALUE_STATE = 4;
+
+	let expressions = [],
+	    tokens = Function.tokenize(query, true),
+	    current_name,
+	    current_operator,
+	    current_value,
+	    current_not,
+	    lower,
+	    token,
+	    type,
+	    value,
+	    i;
+
+	let current_state = START_STATE;
+	let states = [current_state];
+
+	const replaceState = state => {
+		states[states.length - 1] = state;
+		current_state = state;
+	};
+
+	const pushState = state => {
+		current_state = state;
+		states.push(current_state);
+		return current_state;
+	};
+
+	const popState = () => {
+		current_state = states.pop();
+		return current_state;
+	};
+
+	const createGroup = () => {
+
+		if (hasCurrent()) {
+			closeValue();
+		}
+
+		expressions.push(true);
+		pushState(START_STATE);
+	};
+
+	const closeGroup = () => {
+
+		if (hasCurrent()) {
+			closeValue();
+		}
+
+		popState();
+		expressions.push(false);
+	};
+
+	const setValue = (token) => {
+
+		if (token === true) {
+			current_value = true;
+		} else {
+
+			let new_value = {
+				type : token.type,
+				value: token.value,
+				not  : !!current_not,
+			};
+
+			if (current_value) {
+				if (current_value.type == 'name') {
+					current_value.value = current_value.value + new_value.value;
+				} else {
+					reject('Unexpected value');
+				}
+			} else {
+				current_value = new_value;
+			}
+		}
+	};
+
+	const hasCurrent = () => !!(current_name || current_operator || current_value);
+
+	const closeValue = (next_logic_type) => {
+
+		if (!hasCurrent()) {
+			reject('Incomplete statement');
+		}
+
+		let entry = [
+			current_name,
+			current_operator,
+			current_value,
+			current_not,
+			next_logic_type,
+		];
+
+		expressions.push(entry);
+
+		current_name = null;
+		current_operator = null;
+		current_value = null;
+		current_not = null;
+		replaceState(START_STATE);
+	}
+
+	const reject = (message) => {
+		throw new Error(message);
+	};
+
+	for (i = 0; i < tokens.length; i++) {
+		token = tokens[i];
+		type = token.type;
+
+		// All whitespace can be ignored
+		if (type == 'whitespace') {
+			continue;
+		}
+
+		value = token.value;
+
+		if (value == '(') {
+			createGroup();
+			continue;
+		}
+
+		if (value == ')') {
+			closeGroup();
+			continue;
+		}
+
+		lower = value.toLowerCase();
+
+		if (current_state == START_STATE) {
+			if (type != 'name') {
+				reject('Expected name');
+			}
+
+			if (lower == 'not' || lower == 'and' || lower == 'or') {
+				expressions.push(lower);
+			} else {
+				current_name = value;
+				pushState(NAME_STATE);
+			}
+		} else if (current_state == NAME_STATE) {
+
+			if (type == 'punct') {
+				if (value == '.') {
+					current_name += '.';
+				} else {
+					current_operator = value;
+					replaceState(OPERATOR_STATE);
+				}
+			} else if (type == 'name') {
+				if (lower == 'not') {
+					current_not = !current_not;
+					console.log('NOT! Current operator is', current_operator);
+					replaceState(OPERATOR_STATE);
+				} else if (lower == 'is') {
+					current_operator = '==';
+					replaceState(OPERATOR_STATE);
+				} else {
+					current_name += value;
+				}
+			}
+		} else if (current_state == OPERATOR_STATE) {
+
+			// Is there already an operator?
+			if (current_operator) {
+				if (lower == 'not') {
+					current_not = !current_not;
+				} else if (type == 'name' && lower == 'empty') {
+					current_operator = 'empty';
+					setValue(true);
+					replaceState(VALUE_STATE);
+				} else {
+					setValue(token);
+					replaceState(VALUE_STATE);
+				}
+			} else if (type == 'name') {
+				current_operator = lower;
+			} else {
+				reject('Expected operator');
+			}
+		} else if (current_state == VALUE_STATE) {
+
+			if (type == 'name') {
+				if (lower == 'not' && !current_value) {
+					current_not = !current_not;
+				} else if (lower == 'or' || lower == 'and') {
+					if (!current_value) {
+						reject('Expected a value');
+					}
+
+					closeValue(lower);
+					continue;
+				}
+			}
+
+			if (type == 'punct') {
+				if (value == '.') {
+					setValue(token);
+				} else {
+					reject('Unexpected punctuation');
+				}
+			} else if (type == 'name') {
+				setValue(token);
+			} else if (current_value) {
+				reject('Unexpected string');
+			} else {
+				setValue(token);
+			}
+		}
+	}
+
+	if (hasCurrent()) {
+		closeValue();
+	}
+
+	return expressions;
+}
+
+/**
+ * Convert AQL tokens into a conditions object
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @param    {string}   query
+ *
+ * @return   {Object}
+ */
+function convertAQLTokens(expressions, expression_converter) {
+
+	let current_group,
+	    current_logic,
+	    next_is_not,
+	    expression,
+	    i;
+
+	// Make sure there currently exists a group with the given logic type
+	const ensureGroup = (logic) => {
+
+		if (!current_group) {
+			current_group = {
+				logic,
+				expressions: [],
+			};
+		} else {
+
+			if (!current_group.logic) {
+				current_group.logic = logic;
+			} else if (current_group.logic != logic) {
+				pushGroup(logic);
+			}
+		}
+
+		current_logic = current_group.logic;
+
+		return current_group;
+	};
+
+	// Create the root group
+	let root = ensureGroup();
+
+	// Start a new group of the given logic type.
+	const pushGroup = (logic) => {
+
+		let group = {
+			logic,
+			expressions: [],
+			not: next_is_not
+		};
+
+		if (logic == 'or') {
+			group.expressions.push(simplifyGroups(current_group));
+			current_group = current_group.parent;
+		}
+
+		group.parent = current_group;
+
+		if (!current_group) {
+			root = group;
+		} else {
+			current_group.child = group;
+		}
+
+		current_group = group;
+	};
+
+	// Close the current group (& restore the parent group)
+	const closeGroup = () => {
+		let group = current_group;
+		current_group = group.parent;
+	}
+
+	const simplifyGroups = (group) => {
+
+		let result = {};
+		let logic;
+
+		if (group.logic == 'and' || !group.logic) {
+			logic = '$and';
+		} else if (group.logic == 'or') {
+			logic = '$or';
+		} else {
+			throw new Error('Unknown logic type');
+		}
+
+		result[logic] = group.expressions;
+
+		if (group.child) {
+			result[logic].push(simplifyGroups(group.child));
+		}
+
+		if (group.not) {
+			result = {
+				$nor: result
+			};
+		}
+
+		return result;
+	};
+
+	for (i = 0; i < expressions.length; i++) {
+		expression = expressions[i];
+
+		if (expression === true) {
+			pushGroup();
+		} else if (expression === false) {
+			closeGroup();
+		} else if (expression === 'and' || expression === 'or') {
+			ensureGroup(expression);
+		} else if (expression === 'not') {
+			next_is_not = true;
+			continue;
+		} else {
+
+			current_logic = expression[4];
+
+			// And gets precedence
+			if (current_logic == 'and') {
+				ensureGroup(current_logic);
+			}
+
+			expression = expression_converter(...expression);
+
+			current_group.expressions.push(expression);
+
+			if (current_logic == 'or') {
+				ensureGroup(current_logic);
+			}
+		}
+
+		next_is_not = false;
+	}
+
+	return simplifyGroups(root);
+}
+
 /**
  * Get the MongoDB options from this criteria
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.1.0
  * @version  1.1.0
  *
@@ -1011,7 +1565,7 @@ NoSQL.setMethod(function compileCriteriaOptions(criteria) {
 /**
  * Handle items from the datasource
  *
- * @author   Jelle De Loecker   <jelle@develry.be>
+ * @author   Jelle De Loecker <jelle@elevenways.be>
  * @since    1.1.0
  * @version  1.1.0
  *