nodester 0.3.4 → 0.4.0

package/lib/body/extract.js

@@ -65,17 +65,32 @@ function extract(body, filter=null, model) {
 		}
 
 		if (isInclude) {
-			const filterIncludes = Object.keys(filter.includes);
+			const availableIncludeFilters = Object.keys(filter.includes);
 
-			if (filterIncludes.indexOf(key) === -1) {
+			if (availableIncludeFilters.indexOf(key) === -1) {
 				const err = new Error(`Include '${ key }' is not available.`);
 				err.status = httpCodes.NOT_ACCEPTABLE;
 				throw err;
 			}
 
+			const thisIncludeFilter = filter.includes[key];
+
 			const association = model.associations[key];
 	
-			filteredBody[key] = extract(value[0], filter.includes[key], association.target);
+			// Mutliple includes:
+			if (Array.isArray(value)) {
+				filteredBody[key] = [];
+
+				for (let thisIncludeBody of value) {
+					filteredBody[key].push(
+						extract(thisIncludeBody, thisIncludeFilter, association.target)
+					)
+				}
+			}
+			else {
+				const thisIncludeBody = value;
+				filteredBody[key] = extract(thisIncludeBody, thisIncludeFilter, association.target);
+			}
 
 			continue;
 		}

package/lib/facades/methods/index.js

@@ -106,8 +106,8 @@ async function _createOne(params) {
 		});
 
 		const instance = await this.model.create({ ...data }, {
-			include: this.model.getIncludesTree(data)
-		});
+											include: this.model.getIncludesTree(data)
+										});
 
 		const result = {
 			[this.outputName.singular]: instance,
@@ -145,12 +145,11 @@ async function _updateOne(params) {
 			data: null
 		});
 
-		const updateResult = await this.model.updateOne(query.where, data);;
-
-		const [ isNewRecord, instance ] = updateResult;
+		const instance = await this.model.updateOne(query.where, data, {
+												include: this.model.getIncludesTree(data)
+											});
 
 		const result = {
-			success: isNewRecord === false,
 			[this.outputName.singular]: instance,
 			count: 0 + (instance !== null)
 		}

package/lib/middlewares/ql/sequelize/interpreter/ModelsTree.js

@@ -29,8 +29,9 @@ class ModelsTreeNode {
 		this.limit = -1; // No limit
 
 		this._includes = opts.includes ?? [];
-		this.order = opts.order ?? 'asc';
-		this.order_by = opts.order_by ?? 'id';
+
+		this.order = opts.order ?? undefined;
+		this.order_by = opts.order_by ?? undefined;
 	}
 
 	// Getters:

package/lib/models/mixins.js

@@ -86,7 +86,7 @@ async function _createWithIncludes(
 						associatedModel,
 						foreignKey,
 						associationType
-					} = getModelAssociationProps(associationDefinition, data);
+					} = getModelAssociationProps(associationDefinition);
 
 					// If association type is HasMany or HasOne (We don't work with any other):
 					if (associationType === 'HasMany' || associationType === 'HasOne') {
@@ -189,71 +189,108 @@ function _findMany(opts={}) {
 async function _updateOne(
 	where,
 	data,
-	include=[]
+	opts={}
 ) {
 	try {
-		const instance = await this.findOne({ where, include });
+		const include = opts.include ?? [];
+		let instance = await this.findOne({ where, include });
+		let isNewRecord = false;
 
 		if (!instance) {
-			const err = new Error(`Model not found`);
-			err.name = 'NotFound';
-			throw err;
-		}
 
-		// Update parent model instance:
-		instance.set({ ...data });
-		const saveResult = await instance.save();
-		const { isNewRecord } = saveResult;
-
-		// Variable that will contain data from parent instance and associations, mentioned in data.
-		let fullInstanceData = instance.toJSON();
+			if (opts.findOrCreate === true) {
+				instance = await this.create(data);
+				isNewRecord = true;
+			}
+			else {
+				const err = new Error(`Model not found`);
+				err.name = 'NotFound';
+				throw err;
+			}
 
-		// If this model has associations:
-		if (modelHasAssociations(this)) {
+		}
 
-			const associationsEntries = Object.entries(this.associations);
-			for (const [ associationName, associationDefinition ] of associationsEntries) {
+		// Will contain data from parent instance and associations.
+		const fullInstanceData = instance.toJSON();
 
-				// If data of this association is present:
-				if (!!data[associationName]) {
-					
-					// Preparation to work with association:
-					const {
-						associatedModel,
-						foreignKey,
-						associationType
-					} = getModelAssociationProps(associationDefinition, data);
+		const parentData = {
+			...data
+		}
+		for (let includeConfig of include) {
+			const { association } = includeConfig;
 
-					// If association type is HasMany or HasOne (We don't work with any other):
-					if (associationType === 'HasMany' || associationType === 'HasOne') {
+			if (parentData[association] === undefined) {
+				continue;
+			}
 
-						// Process current instance.
-						const operationsResults = await _updateOrCreateOrDeleteBasedOnAssociationData({
-							associatedModel: associatedModel,
-							dataOfAssociation: data[associationName],
-							parentModelId: instance.id,
-							parentForeignKey: foreignKey,
-						});
+			delete parentData[association];
+
+			const associationDefinition = this.associations[association];
+			const includeData = data[association];
+			
+			const {
+				associatedModel,
+				associationType,
+				
+				foreignKey,
+				sourceKey
+			} = getModelAssociationProps(associationDefinition);
+
+			const associationUpdateOpts = {
+				findOrCreate: true,
+				include: associatedModel.getIncludesTree(includeData)
+			};
+
+			const pkField = associatedModel.primaryKeyField;
+
+			// If association type is HasMany or HasOne (We don't work with any other):
+			switch(associationType) {
+				case 'HasMany': {
+					const promises = includeData.map(singleData => {
+						// Note: for now we are only able to work with a model with single PrimaryKey:
+						const where = {
+							[pkField]: singleData[pkField]
+						}
+						return associatedModel.updateOne(
+										where,
+										singleData,
+										associationUpdateOpts
+									)
+					});
+					fullInstanceData[association] = await Promise.all(promises);
+
+					continue;
+				}
 
-						fullInstanceData[associationName] = _unwrapUpdateOrCreateOrDeleteOperationsResults(
-							operationsResults,
-							associationType
-						);
+				case 'HasOne': {
+					// Note: for now we are only able to work with a model with single PrimaryKey:
+					const where = {
+						[pkField]: includeData[pkField]
 					}
+					fullInstanceData[association] = await associatedModel.updateOne(
+																						where,
+																						includeData,
+																						associationUpdateOpts
+																					);
 
-					fullInstanceData[associationName] = fullInstanceData[associationName] ?? data[associationName];
+					continue;
 				}
-			}
 
+				default:
+					continue;
+			}
 		}
-		
-		// Select this instance again, if includes was set:
-		if (include?.length > 0) {
-			const updatedInstance = await this.findOne({ where, include });
-			fullInstanceData = updatedInstance.toJSON();
+
+		// Update parent model instance:
+		if (isNewRecord === false) {
+			instance.set(parentData);
+			const saveResult = await instance.save();
 		}
 
-		return Promise.resolve([ isNewRecord, fullInstanceData ]);
+		return Promise.resolve({
+			_is_new_record: isNewRecord,
+			...fullInstanceData
+		});
 	}
 	catch(error) {
 		return Promise.reject(error);
@@ -263,13 +300,13 @@ async function _updateOne(
 async function _updateById(
 	id=null,
 	data={},
-	include=[]
+	opts={}
 ) {
 	const where = { id };
 	return this.updateOne(
 		where,
 		data,
-		include
+		opts
 	);
 }
 

package/lib/query/{traverse.js → traverse/index.js}

@@ -5,7 +5,7 @@
  
 'use strict';
 
-const BOUNDS = require('../constants/Bounds');
+const BOUNDS = require('../../constants/Bounds');
 
 const { Op } = require('sequelize');
 const { NodesterQueryError } = require('nodester/errors');
@@ -13,6 +13,20 @@ const httpCodes = require('nodester/http/codes');
 
 const { ensure } = require('nodester/validators/arguments');
 
+const {
+	parseValue,
+	parseWhereEntry,
+} = require('./parsers');
+
+const {
+	disassembleQueryNode,
+	addAssociationQuery,
+} = require('./utils');
+
+const {
+	getModelAssociationProps
+} = require('../../utils/modelAssociations.util');
+
 
 module.exports = traverse;
 
@@ -58,7 +72,7 @@ function traverse(queryNode, filter=null, model=null) {
 		where,
 
 		includes,
-	} = _disassembleQueryNode(queryNode);
+	} = disassembleQueryNode(queryNode);
 
 
 	// Attribute:
@@ -200,10 +214,16 @@ function traverse(queryNode, filter=null, model=null) {
 				continue;
 			}
 			case 'order':
+				if (value === undefined)
+					continue;
+
 				order.order = value;
 				continue;
 
 			case 'order_by':
+				if (value === undefined)
+					continue;
+
 				order.by = value;
 				continue;
 				
@@ -303,13 +323,13 @@ function traverse(queryNode, filter=null, model=null) {
 	//	Set aatributes from Query:
 	const whereEntries = Object.entries(where);
 	for (let [ attribute, value ] of whereEntries) {
-		_parseWhereEntry(attribute, value, newQuery.where);
+		parseWhereEntry(attribute, value, newQuery.where);
 	}
 
 	//	Static attributes override previously set attributes:
 	const staticAttributesEntries = Object.entries(filter.statics.attributes);
 	for (let [ attribute, staticValue ] of staticAttributesEntries) {
-		newQuery.where[attribute] = _parseValue(staticValue, attribute);
+		newQuery.where[attribute] = parseValue(staticValue, attribute);
 	}
 
 	//	If "where" was not set in any way,
@@ -319,6 +339,12 @@ function traverse(queryNode, filter=null, model=null) {
 	}
 	// Where\
 
+	// Combine included orders into one at the top level:
+	// - Why?
+	// - Sequelize ingores included orders for association types like:
+	//   • HasMany
+	_traverseIncludedOrders(newQuery, _model);
+
 	return newQuery;
 }
 
@@ -355,66 +381,46 @@ function _traverseIncludes(includes, rootModel, filter, resultQuery) {
 		// Build query for this include.
 		const associationQuery = traverse(include, filter.includes[includeName], includeModel);
 
-		_addAssociationQuery(associationQuery, includeName, resultQuery);
+		addAssociationQuery(associationQuery, includeName, resultQuery);
 	}
 }
 
+function _traverseIncludedOrders(resultQuery, rootModel) {
+	for (let i=0; i < resultQuery.include.length; i++) {
+		const include = resultQuery.include[i];
 
-function _addAssociationQuery(associationQuery, includeName, resultQuery) {
-
-	// Add all association info into query.
-	resultQuery.include.push({
-		association: includeName,
-		...associationQuery
-	});
-}
-
-
-function _parseWhereEntry(attribute, value, whereHolder) {
-	let _value = value;
-
-	// If attribute is Op (not, like, or, etc.):
-	if (attribute in Op) {
-		// Parse value:
-		_value = _parseValue(_value, attribute);
-
-		const op = Op[attribute];
-		whereHolder[op] = _value;
-		return;
-	}
-
-	whereHolder[attribute] = _parseValue(_value, attribute);
-}
+		console.log({ irder: include?.order });
+		if (!include?.order) {
+			continue;
+		}
 
-function _disassembleQueryNode(queryNode) {
-	// Disassemble current query node:
-	const {
-		attributes,
-		functions,
-		where,
-		includes,
-		...clauses
-	} = queryNode;
-
-	return {
-		attributes: attributes ?? [],
-		clauses: clauses ?? [],
-		functions: functions ?? [],
-		where: where ?? {},
-		includes: includes ?? [],
-	};
-}
+		if (!resultQuery.order) {
+			resultQuery.order = [];
+		}
 
-function _parseValue(value, attribute) {
-	// If value is Object:
-	if (typeof value === 'object' && Array.isArray(value) === false) {
-		const [ opKey, rawValue ] = (Object.entries(value))[0];
+		const { association } = include;
+		const {
+			associatedModel,
+			associationType
+		} = getModelAssociationProps(rootModel.associations[association]);
+
+		switch(associationType) {
+			case 'HasMany': {
+				resultQuery.order.push([
+					{ association },
+					...include.order[0]
+				]);
+				delete resultQuery.include[i].order;
+				break;
+			}
+			default:
+				break;
+		}
 
-		const op = Op[opKey];
-		return { [op]: rawValue };
+		_traverseIncludedOrders(resultQuery.include[i], associatedModel);
 	}
 
-	return value;
+	return resultQuery;
 }
 
 function _setValueWithBounds(value, type, bounds) {

package/lib/query/traverse/parsers.js

@@ -0,0 +1,41 @@
+/**
+ * nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
+
+
+module.exports = {
+	parseValue: _parseValue,
+	parseWhereEntry: _parseWhereEntry,
+}
+
+function _parseValue(value, attribute) {
+	// If value is Object:
+	if (typeof value === 'object' && Array.isArray(value) === false) {
+		const [ opKey, rawValue ] = (Object.entries(value))[0];
+
+		const op = Op[opKey];
+		return { [op]: rawValue };
+	}
+
+	return value;
+}
+
+function _parseWhereEntry(attribute, value, whereHolder) {
+	let _value = value;
+
+	// If attribute is Op (not, like, or, etc.):
+	if (attribute in Op) {
+		// Parse value:
+		_value = _parseValue(_value, attribute);
+
+		const op = Op[attribute];
+		whereHolder[op] = _value;
+		return;
+	}
+
+	whereHolder[attribute] = _parseValue(_value, attribute);
+}
+

package/lib/query/traverse/utils.js

@@ -0,0 +1,40 @@
+/**
+ * nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
+
+
+module.exports = {
+	disassembleQueryNode: _disassembleQueryNode,
+	addAssociationQuery: _addAssociationQuery,
+}
+
+function _disassembleQueryNode(queryNode) {
+	// Disassemble current query node:
+	const {
+		attributes,
+		functions,
+		where,
+		includes,
+		...clauses
+	} = queryNode;
+
+	return {
+		attributes: attributes ?? [],
+		clauses: clauses ?? [],
+		functions: functions ?? [],
+		where: where ?? {},
+		includes: includes ?? [],
+	};
+}
+
+function _addAssociationQuery(associationQuery, includeName, resultQuery) {
+
+	// Add all association info into query.
+	resultQuery.include.push({
+		association: includeName,
+		...associationQuery
+	});
+}

package/lib/utils/modelAssociations.util.js

@@ -1,3 +1,10 @@
+/**
+ * nodester
+ * MIT Licensed
+ */
+ 
+'use strict';
+
 
 module.exports = {
 	modelHasAssociations: _modelHasAssociations,
@@ -10,12 +17,16 @@ function _modelHasAssociations(modelDifinition) {
 }
 
 function _getModelAssociationProps(
-	associationDefinition,
-	requestData
+	associationDefinition
 ) {
 	// Extract neccessary variables and functions:
 	const associatedModel = associationDefinition.target;
-	const { foreignKey } = associationDefinition.options;
+	
+	const {
+		foreignKey,
+		sourceKey
+	} = associationDefinition;
+
 	const {
 		associationType,
 		accessors,
@@ -23,8 +34,11 @@ function _getModelAssociationProps(
 
 	return {
 		associatedModel,
-		foreignKey,
 		associationType,
+
+		foreignKey,
+		sourceKey,
+
 		accessors,
 	};
 }

package/lib/utils/sanitizations.util.js

@@ -7,8 +7,14 @@
 
 
 module.exports = {
+	UUID: _UUID,
+
 	CHAR: _STRING,
 	VARCHAR: _STRING,
+	STRING: _STRING,
+	TEXT: _TEXT,
+
+	ENUM: _ENUM,
 
 	NUMBER: _NUMBER,
 	
@@ -17,8 +23,6 @@ module.exports = {
 
 	BOOLEAN: _BOOLEAN,
 	
-	STRING: _STRING,
-	TEXT: _TEXT,
 
 	DATE: _DATE,
 	DATETIME: _DATE,
@@ -26,6 +30,52 @@ module.exports = {
 	JSON: _JSON
 }
 
+function _UUID(value=undefined, options={ fallback:undefined }) {
+	try {
+		if (typeof value !== 'string')
+			throw new Error(`Not a valid UUID`);
+			
+		return value;
+	}
+	catch(ex) {
+		return options?.fallback;
+	}
+}
+
+
+function _STRING(value=undefined, options={ fallback:undefined }) {
+	try {
+		if (typeof value !== 'string')
+			throw new Error(`Not a String`);
+			
+		return value;
+	}
+	catch(ex) {
+		return options?.fallback;
+	}
+}
+
+function _TEXT(value=undefined, options={ fallback:undefined }) {
+	try {
+		if (typeof value !== 'string')
+			throw new Error(`Not a String`);
+			
+		return value;
+	}
+	catch(ex) {
+		return options?.fallback;
+	}
+}
+
+
+function _ENUM(value=undefined, options={ fallback:undefined }) {
+	if (value === undefined)
+		return options.fallback;
+
+	return value;
+}
+
+
 function _isNumber(value) {
 	return !isNaN(`${value}`);
 }
@@ -70,29 +120,6 @@ function _BOOLEAN(value=undefined, options={ fallback:undefined }) {
 	}
 }
 
-function _STRING(value=undefined, options={ fallback:undefined }) {
-	try {
-		if (typeof value !== 'string')
-			throw new Error(`Not a String`);
-			
-		return value;
-	}
-	catch(ex) {
-		return options?.fallback;
-	}
-}
-
-function _TEXT(value=undefined, options={ fallback:undefined }) {
-	try {
-		if (typeof value !== 'string')
-			throw new Error(`Not a String`);
-			
-		return value;
-	}
-	catch(ex) {
-		return options?.fallback;
-	}
-}
 
 function _DATE(value=undefined, options={ fallback:undefined }) {
 	try {
@@ -123,6 +150,7 @@ function _DATE(value=undefined, options={ fallback:undefined }) {
 	}
 }
 
+
 function _JSON(value=undefined, options={ fallback:undefined }) {
 	try {
 		if (typeof value === 'string')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodester",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "A versatile REST framework for Node.js",
   "directories": {
     "docs": "docs",
@@ -57,7 +57,7 @@
     "./params": "./lib/structures/Params.js",
 
     "./ql/sequelize": "./lib/middlewares/ql/sequelize/index.js",
-    "./query/traverse": "./lib/query/traverse.js",
+    "./query/traverse": "./lib/query/traverse/index.js",
 
     "./route": "./lib/router/route.js",
     "./router": "./lib/router/index.js",