nodester 0.0.1 → 0.0.2

package/lib/controllers/mixins/index.js

@@ -0,0 +1,222 @@
+const {
+	getOne,
+	getMany,
+	createOne,
+	updateOne,
+	deleteOne
+} = require('../methods');
+
+
+module.exports = {
+	withDefaultCRUD: _withDefaultCRUD,
+	withDefaultErrorProcessing: _withDefaultErrorProcessing,
+	setMethod: _setMethod
+}
+
+
+/**
+ * Sets one of or all of CRUD methods to Controller.
+ *
+ * @param {Function|Object} controller
+ * @param {Object} opts
+ * - @param {Function|Object} facade
+ * - @param {String} name
+ * - @param {Array} only
+ *
+ * @return {Function|Object} controller
+ *
+ * @api public
+ * @alias withDefaultCRUD
+ */
+function _withDefaultCRUD(controller, opts={}) {
+	const {
+		facade,
+
+		// Optional:
+		name,
+		only
+	} = opts;
+
+	if (!controller) {
+		const err = new TypeError(`'controller' argument is not provided.`);
+		throw err;
+	}
+
+	if (!facade) {
+		const err = new TypeError(`'opts.facade' argument is invalid.`);
+		throw err;
+	}
+
+	// Set main facade:
+	if (facade.constructor.name === 'Function') {
+		controller.facade = new facade();
+	}
+	else {
+		controller.facade = facade;
+	}
+
+	// Set model info:
+	const model = facade.model;
+	// Extract plural name of this model.
+	const modelPluralName = model?.options?.name?.plural;
+	// Set name of this controller:
+	Object.defineProperty(controller, 'name', {
+		value: name ?? `${ modelPluralName ?? controller.name }Controller`,
+		writable: false
+	});
+
+
+	// If only certain methods should be set:
+	if (!!only) {
+		for (const selectedMethod of only) {
+			switch(selectedMethod) {
+				case 'getOne':
+					controller.getOne    = getOne.bind(controller);
+					break;
+				case 'getMany':
+					controller.getMany   = getMany.bind(controller);
+					break;
+				case 'createOne':
+					controller.createOne = createOne.bind(controller);
+					break;
+				case 'updateOne':
+					controller.updateOne = updateOne.bind(controller);
+					break;
+				case 'deleteOne':
+					controller.deleteOne = deleteOne.bind(controller);
+					break;
+
+				default:
+					break;
+			}
+		}
+	}
+	// Or set all methods:
+	else {
+		controller.getOne    = getOne.bind(controller);
+		controller.getMany   = getMany.bind(controller);
+		controller.createOne = createOne.bind(controller);
+		controller.updateOne = updateOne.bind(controller);
+		controller.deleteOne = deleteOne.bind(controller);
+
+		// Set empty hooks:
+		controller.afterGetOne    = async () => {};
+		controller.afterGetMany   = async () => {};
+		controller.afterCreateOne = async () => {};
+		controller.afterUpdateOne = async () => {};
+		controller.afterDeleteOe  = async () => {};
+	}
+
+	// TODO: remove.
+	controller.respondOk = (res, data) => res.json(data);
+	controller.respondNotOk = (res, data) => { res.status(data.status); res.json(data); };
+
+	return controller;
+}
+
+
+/**
+ * Sets default error responses to Controller.
+ *
+ * @param {Function|Object} controller
+ * @param {Object} opts
+ *
+ * @return {Function|Object} controller
+ *
+ * @api public
+ * @alias withDefaultErrorProcessing
+ */
+function _withDefaultErrorProcessing(controller, opts={}) {
+	if (!controller) {
+		const err = new TypeError(`'controller' argument is not provided.`);
+		throw err;
+	}
+
+	// Set processError:
+	controller.processError = function (error, req, res) {
+		
+		// Default error message.
+		let errorMessage = error?.message ?? 'Internal server error';
+		// Default HTTP status code.
+		let statusCode = error?.status ?? error?.statusCode ?? 500;
+		// Error response object.
+		let errorResponse = {};
+
+		switch(error.name) {
+			case('Unauthorized'): {
+				statusCode = 401;
+				errorResponse.details = { message: 'Unauthorized' };
+				break;
+			}
+			case('NotFound'): {
+				statusCode = 404;
+				errorResponse.details = { message: errorMessage };
+				break;
+			}
+			case('ValidationError'): {
+				statusCode = 406;
+				errorResponse.details = error?.details;
+				break;
+			}
+			case('ConflictError'): {
+				statusCode = 409;
+				errorResponse.details = error?.details ?? error?.message;
+				break;
+			}
+			case('SequelizeUniqueConstraintError'): {
+				statusCode = 409;
+				errorResponse.details = error?.errors;
+				break;
+			}
+			case('InternalValidationError'): {
+				statusCode = 500;
+				errorResponse.details = { message:'Error' };
+				break;
+			}
+			default: {
+				errorResponse.details = { message: errorMessage };
+				break;
+			}
+		}
+
+		// Send error response with provided status code:
+		const data = {
+				error: {
+				...errorResponse,
+				code: statusCode
+			},
+			status: statusCode
+		}
+
+		if (!!this.respondNotOk) {
+			return this.respondNotOk(res, data);
+		}
+
+		// Barebones response:
+		res.status(statusCode);
+		res.json(data);
+	}
+
+	return controller;
+}
+
+
+/**
+ * Sets one of CRUD methods to Controller.
+ *
+ * @param {Function|Object} controller
+ * @param {Object} opts
+ *
+ * @return {Function|Object} controller
+ *
+ * @api public
+ * @alias withDefaultCRUD
+ */
+function _setMethod(controller,) {
+	if (!controller) {
+		const err = new TypeError(`'controller' argument is not provided.`);
+		throw err;
+	}
+
+
+}

package/lib/database/connection.js

@@ -0,0 +1,34 @@
+// ORM.
+const Sequelize = require('sequelize');
+
+
+module.exports = {
+	buildConnection: _buildConnection
+};
+
+function _buildConnection(opts={}) {
+	
+
+	const dbName = opts.name;
+	const username = opts.username;
+	const password = opts.password;
+
+
+	const connection = new Sequelize(
+		dbName,
+		username,
+		password,
+		{
+			host: opts.host,
+			port: opts.port,
+			dialect: opts.dialect,
+			pool: opts.pool,
+			charset: opts.charset,
+			collate: opts.collate, 
+			timestamps: opts.timestamps,
+			logging: opts.logging
+		}
+	);
+
+	return connection;
+}

package/lib/database/migration.js

@@ -0,0 +1,42 @@
+const { associateModels } = require('./utils');
+
+
+module.exports = {
+	migrate: _migrate
+}
+
+async function _migrate(databaseConnection, force=false) {
+	try {
+		// Validation of 'force' parameter.
+		if (typeof force !== 'boolean') {
+			const err = new Error('Wrong "force" parameter; must be boolean.');
+			throw err;
+		}
+
+		// Test connection.
+		await databaseConnection.authenticate();
+
+
+		const models = databaseConnection.models;
+		const modelNames = Object.keys(models);
+		console.info('Models to sync:', modelNames);
+		console.info('Forcefully?', force);
+		console.info('Syncing...\n');
+		await associateModels(models);
+		await databaseConnection.sync({ force });
+		console.info('Successful migration!');
+
+		const output = {
+			synced: true,
+			modelNames: modelNames,
+			models: models
+		}
+		return Promise.resolve(output);
+	}
+	catch(error) {
+		console.error('Migration failed!');
+		console.error(error);
+		return Promise.reject(error);
+	}
+}
+

package/lib/database/utils.js

@@ -0,0 +1,19 @@
+
+module.exports = {
+	associateModels: _associateModels
+}
+
+async function _associateModels(models) {
+	return new Promise((resolve, reject) => {
+		try {
+			Object.keys(models).map(modelName => (
+				models[modelName].associate(models)
+			));
+
+			return resolve(models);
+		}
+		catch(error) {
+			reject(error);
+		}
+	});
+}

package/lib/enums/Enum.js

@@ -0,0 +1,16 @@
+
+module.exports = Enum;
+
+function Enum(constantsList = {}, writable=false) {
+	const def = (key, value) => Object.defineProperty(this, key, { value, writable: !!writable });
+
+	// Set list.
+	def('list', constantsList);
+
+	// Set getters:
+	Object.keys(constantsList)
+				.forEach(key => def(key, constantsList[key]) );
+
+	// Set constants in static array.
+	def('asArray', Object.values(constantsList) );
+}

package/lib/facades/methods/index.js

@@ -0,0 +1,173 @@
+const Params = require('nodester/params');
+
+
+module.exports = {
+	getOne: _getOne,
+	getMany: _getMany,
+	createOne: _createOne,
+	updateOne: _updateOne,
+	deleteOne: _deleteOne
+}
+
+
+/*
+ *
+ * @param {Object} params
+ *
+ * @alias getOne
+ * @api public
+ */
+async function _getOne(params) {
+	try {
+		const {
+			query
+		} = Params(params, {
+			query: {}
+		});
+
+		const instance = await this.model.findOne(query);
+
+		const result = {
+			[this.modelName.singular]: instance,
+			count: 0 + instance !== null
+		}
+		return Promise.resolve(result);
+	}
+	catch(error) {
+		return Promise.reject(error);
+	}
+}
+
+
+/*
+ *
+ * @param {Object} params
+ *
+ * @alias getMany
+ * @api public
+ */
+async function _getMany(params) {
+	try {
+		const {
+			query
+		} = Params(params, {
+			query: {}
+		});
+
+		const instances = await this.model.findAll(query);
+
+		const result = {
+			[this.modelName.plural]: instances,
+			count: instances.length
+		}
+		return Promise.resolve(result);
+	}
+	catch(error) {
+		return Promise.reject(error);
+	}
+}
+
+
+/*
+ *
+ * @param {Object} params
+ *
+ * @alias createOne
+ * @api public
+ */
+async function _createOne(params) {
+	try {
+		const {
+			data,
+			includes,
+		} = Params(params, {
+			data: null,
+			includes: null,
+		});
+
+		const instance = await this.model.create({ ...data }, {
+			include: this.model.getIncludesList(data)
+		});
+
+		// If includes are set, "find" this record with includes:
+		if (!!includes && includes?.length > 0) {
+			await instance.reload({ include: includes });
+		}
+
+		const result = {
+			[this.modelName.singular]: instance,
+			count: instance === null ? 0 : 1
+		}
+
+		// Call after create.
+		await this.afterCreateOne(instance, params, result);
+
+		return Promise.resolve(result);
+	}
+	catch(error) {
+		return Promise.reject(error);
+	}
+}
+
+
+/*
+ *
+ * @param {Object} params
+ *
+ * @alias updateOne
+ * @api public
+ */
+async function _updateOne(params) {
+	try {
+		const {
+			query,
+			data
+		} = Params(params, {
+			query: {},
+			data: null
+		});
+
+		const updateResult = await this.model.updateOne(query.where, data);;
+
+		const [ isNewRecord, instance ] = updateResult;
+
+		const result = {
+			success: isNewRecord === false,
+			[this.modelName.singular]: instance,
+			count: !!instance ? 1 : 0
+		}
+		return Promise.resolve(result);
+	}
+	catch(error) {
+		return Promise.reject(error);
+	}
+}
+
+
+/*
+ *
+ * @param {Object} params
+ *
+ * @alias deleteOne
+ * @api public
+ */
+async function _deleteOne(params) {
+	try {
+		const {
+			query
+		} = Params(params, {
+			query: null
+		});
+
+		const count = await this.model.deleteOne(query);
+
+		const result = {
+			success: count > 0,
+			count: count
+		};
+		return Promise.resolve(result);
+	}
+	catch(error) {
+		return Promise.reject(error);
+	}
+}

package/lib/facades/mixins/index.js

@@ -0,0 +1,111 @@
+const {
+	getOne,
+	getMany,
+	createOne,
+	updateOne,
+	deleteOne
+} = require('../methods');
+// Utils,
+const { lowerCaseFirstLetter } = require('nodester/utils/strings');
+
+
+module.exports = {
+	withDefaultCRUD: _withDefaultCRUD,
+}
+
+/**
+ * Sets one of or all of CRUD methods to Facade.
+ *
+ * @param {Function|Object} facade
+ * @param {Object} opts
+ * - @param {Function|Object} model
+ * - @param {String} name
+ * - @param {Array} only
+ *
+ * @return {Function|Object} facade
+ *
+ * @api public
+ * @alias withDefaultCRUD
+ */
+function _withDefaultCRUD(facade, opts={}) {
+	const {
+		model,
+
+		// Optional:
+		name,
+		only
+	} = opts;
+
+	if (!facade) {
+		const err = new TypeError(`'facade' argument is not provided.`);
+		throw err;
+	}
+	
+	// Set model info:
+	//	Set model:
+	Object.defineProperty(facade, 'model', {
+		value: model,
+		writable: false
+	});
+
+	//	Model name:
+	const modelName = model.options.name;
+	Object.defineProperty(facade, 'modelName', {
+		value: {
+			singular: lowerCaseFirstLetter(modelName.singular),
+			plural: lowerCaseFirstLetter(modelName.plural)
+		},
+		writable: false
+	});
+
+
+	// Set name of this facade:
+	Object.defineProperty(facade, 'name', {
+		value: name ?? `${ modelName.plural ?? facade.name }Facade`,
+		writable: false
+	});
+
+
+	// If only certain methods should be set:
+	if (!!only) {
+		for (const selectedMethod of only) {
+			switch(selectedMethod) {
+				case 'getOne':
+					facade.getOne    = getOne.bind(facade);
+					break;
+				case 'getMany':
+					facade.getMany   = getMany.bind(facade);
+					break;
+				case 'createOne':
+					facade.createOne = createOne.bind(facade);
+					break;
+				case 'updateOne':
+					facade.updateOne = updateOne.bind(facade);
+					break;
+				case 'deleteOne':
+					facade.deleteOne = deleteOne.bind(facade);
+					break;
+
+				default:
+					break;
+			}
+		}
+	}
+	// Or set all methods:
+	else {
+		facade.getOne    = getOne.bind(facade);
+		facade.getMany   = getMany.bind(facade);
+		facade.createOne = createOne.bind(facade);
+		facade.updateOne = updateOne.bind(facade);
+		facade.deleteOne = deleteOne.bind(facade);
+
+		// Set empty hooks:
+		facade.afterGetOne    = async () => {};
+		facade.afterGetMany   = async () => {};
+		facade.afterCreateOne = async () => {};
+		facade.afterUpdateOne = async () => {};
+		facade.afterDeleteOe  = async () => {};
+	}
+
+	return facade;
+}

package/lib/factories/errors/CustomError.js

@@ -1,6 +1,8 @@
-class CustomError extends Error {
+
+module.exports = class CustomError extends Error {
 	constructor(message) {
 		super(message);
+
 		this.name = this.constructor.name;
 		this.status = 500;
 
@@ -14,9 +16,9 @@ class CustomError extends Error {
 		this.status = originalError?.status ?? this.status;
 
 		// Append stack from original error.
-		const messageLines = (this.message.match(/\n/g)||[]).length + 1
-		this.stack = this.stack.split('\n').slice(0, messageLines+1).join('\n') + '\n' + originalError.stack;
+		const linesCount = (this.message.match(/\n/g)||[]).length + 1;
+		this.stack = this.stack.split('\n')
+													 .slice(0, linesCount+1)
+													 .join('\n') + '\n' + originalError.stack;
 	}
 }
-
-module.exports = CustomError;

package/lib/factories/responses/html.js

@@ -1,7 +1,12 @@
-const Params = require('nodester/facades/FacadeParams');
+/*
+ * WARNING: Unfinihsed. Do not use!
+ *
+ */
 
+const Params = require('../../params/Params');
 
-module.exports = class WebResponseFactory {
+
+module.exports = class HtmlResponseFactory {
 	constructor() {}
 
 	/**