nodester 0.0.1 → 0.0.6

package/lib/controllers/mixins/index.js

@@ -0,0 +1,213 @@
+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.
+		return this.respondNotOk(res, {
+			error: {
+				...errorResponse,
+				code: statusCode
+			},
+			status: statusCode
+		});
+	}
+
+	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/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/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() {}
 
 	/**

package/lib/factories/responses/rest.js

@@ -0,0 +1,110 @@
+/*
+ * Rest response factory.
+ */
+
+const ResponseFormats = require('../../constants/ResponseFormats');
+
+
+module.exports = {
+	createGenericResponse: _createGenericResponse,
+	createOKResponse: _createOKResponse,
+	createErrorResponse: _createErrorResponse,
+}
+
+
+/*
+ * Format for all API responses will be JSON
+ * {
+ * 	content: {...}
+ * 	error: {...}
+ * }
+ * Status code is sent in header.
+ * 	
+ * If error is not present, error should be null.
+ * If error is present, content can be null (But it's not required).
+ *
+ * @param {ServerResponse} res
+ * @param {Object} options
+ *
+ * @alias createGenericResponse
+ * @api public
+*/
+function _createGenericResponse(
+	res,
+	options = {
+		status: 200,
+		content: {},
+		error: null,
+		format: ResponseFormats.JSON
+	}
+) {
+	try {
+		const data = {
+			content: options?.content ?? null,
+			error: options?.error ?? null
+		};
+
+		switch(options?.format) {
+			case ResponseFormats.JSON:
+				return options?.res.status(options?.status).json(data);
+			case ResponseFormats.XML:
+				// TODO: format data into XML.
+				return options?.res.status(options?.status).send(data);
+				break;
+			default: {
+				const err = new TypeError("No format specified.");
+				throw err;
+			}
+		}
+	}
+	catch(error) {
+		const err = new Error(`Could not create generic response: ${error.message}`);
+		err.name = error?.name;
+		err.code = error?.code;
+		throw err;
+	}
+}
+
+
+/**
+ * Sends response with status code 200.
+ * Should be called on all successful respones.
+ *
+ * @param {ServerResponse} res
+ * @param <Object> content
+ * @param <String> format
+ *
+ * @alias createOKResponse
+ * @api public
+ */
+function _createOKResponse(res, options={}) {
+
+	return this.createGenericResponse(res, { 
+		...options,
+		status: 200,
+		format: options?.format ?? ResponseFormats.JSON
+	});
+}
+
+
+/**
+ * Sends response with provided error code.
+ * Should be called on all failed respones.
+ *
+ * @param {ServerResponse} res
+ * @param <Object> error
+ * @param <Object> content (optional)
+ * @param <Int>		 status
+ * @param <String> format
+ *
+ * @alias createErrorResponse
+ * @api public
+ */
+function _createErrorResponse(res, options) {
+
+	return this.createGenericResponse(res, {
+		...options,
+		status: options?.status ?? 500,
+		format: options?.format ?? ResponseFormats.JSON
+	});
+}

package/lib/http/codes/index.js

@@ -0,0 +1,157 @@
+const symbolsByTag = {
+	// Informational:
+	CONTINUE: Symbol('100: Continue'),
+	SWITCHING_PROTOCOLS: Symbol('101: Switching Protocols'),
+	PROCESSING: Symbol('102: Processing'),
+	EARLY_HINTS: Symbol('103: Early Hints'),
+
+	// Success:
+	OK: Symbol('200: OK'),
+	CREATED: Symbol('201: Created'),
+	ACCEPTED: Symbol('202: Accepted'),
+	NON_AUTHORITATIVE_INFORMATION: Symbol('203: Non-Authoritative Information'),
+	NO_CONTENT: Symbol('204: No Content'),
+	RESET_CONTENT: Symbol('205: Reset Content'),
+	PARTIAL_CONTENT: Symbol('206: Partial Content'),
+	MULTI_STATUS: Symbol('207: Multi-Status'),
+	ALREADY_REPORTED: Symbol('208: Already Reported'),
+	IM_USED: Symbol('226: IM Used'),
+
+	// Redirections:
+	MULTIPLE_CHOICES: Symbol('300: Multiple Choices'),
+	MOVED_PERMANENTLY: Symbol('301: Moved Permanently'),
+	FOUND: Symbol('302: Found'),
+	SEE_OTHER: Symbol('303: See Other'),
+	NOT_MODIFIED: Symbol('304: Not Modified'),
+	USE_PROXY: Symbol('305: Use Proxy'),
+	TEMPORARY_REDIRECT: Symbol('307: Temporary Redirect'),
+	PERMANENT_REDIRECT: Symbol('308: Permanent Redirect'),
+
+	// Client Errors:
+	BAD_REQUEST: Symbol('400: Bad Request'),
+	UNAUTHORIZED: Symbol('401: Unauthorized'),
+	PAYMENT_REQUIRED: Symbol('402: Payment Required'),
+	FORBIDDEN: Symbol('403: Forbidden'),
+	NOT_FOUND: Symbol('404: Not Found'),
+	METHOD_NOT_ALLOWED: Symbol('405: Method Not Allowed'),
+	NOT_ACCEPTABLE: Symbol('406: Not Acceptable'),
+	PROXY_AUTHENTICATION_REQUIRED: Symbol('407: Proxy Authentication Required'),
+	REQUEST_TIMEOUT: Symbol('408: Request Timeout'),
+	CONFLICT: Symbol('409: Conflict'),
+	GONE: Symbol('410: Gone'),
+	LENGTH_REQUIRED: Symbol('411: Length Required'),
+	PRECONDITION_FAILED: Symbol('412: Precondition Failed'),
+	PAYLOAD_TOO_LARGE: Symbol('413: Payload Too Large'),
+	URI_TOO_LONG: Symbol('414: URI Too Long'),
+	UNSUPPORTED_MEDIA_TYPE: Symbol('415: Unsupported Media Type'),
+	RANGE_NOT_SATISFIABLE: Symbol('416: Range Not Satisfiable'),
+	EXPECTATION_FAILED: Symbol('417: Expectation Failed'),
+	IM_A_TEAPOT: Symbol("418: I'm a teapot"),
+	MISDIRECTED_REQUEST: Symbol('421: Misdirected Request'),
+	UNPROCESSABLE_ENTITY: Symbol('422: Unprocessable Entity'),
+	LOCKED: Symbol('423: Locked'),
+	FAILED_DEPENDENCY: Symbol('424: Failed Dependency'),
+	TOO_EARLY: Symbol('425: Too Early'),
+	UPGRADE_REQUIRED: Symbol('426: Upgrade Required'),
+	PRECONDITION_REQUIRED: Symbol('428: Precondition Required'),
+	TOO_MANY_REQUESTS: Symbol('429: Too Many Requests'),
+	REQUEST_HEADER_FIELDS_TOO_LARGE: Symbol('431: Request Header Fields Too Large'),
+	UNAVAILABLE_FOR_LEGAL_REASONS: Symbol('451: Unavailable For Legal Reasons'),
+
+	// Server Errors:
+	INTERNAL_SERVER_ERROR: Symbol('500: Internal Server Error'),
+	NOT_IMPLEMENTED: Symbol('501: Not Implemented'),
+	BAD_GATEWAY: Symbol('502: Bad Gateway'),
+	SERVICE_UNAVAILABLE: Symbol('503: Service Unavailable'),
+	GATEWAY_TIMEOUT: Symbol('504: Gateway Timeout'),
+	HTTP_VERSION_NOT_SUPPORTED: Symbol('505: HTTP Version Not Supported'),
+	VARIANT_ALSO_NEGOTIATES: Symbol('506: Variant Also Negotiates'),
+	INSUFFICIENT_STORAGE: Symbol('507: Insufficient Storage'),
+	LOOP_DETECTED: Symbol('508: Loop Detected'),
+	NOT_EXTENDED: Symbol('510: Not Extended'),
+	NETWORK_AUTHENTICATION_REQUIRED: Symbol('511: Network Authentication Required')
+}
+
+const descriptionsByCode = {
+	// Informational:
+	100: 'Continue',
+	101: 'Switching Protocols',
+	102: 'Processing',
+	103: 'Early Hints',
+
+	// Success:
+	200: 'OK',
+	201: 'Created',
+	202: 'Accepted',
+	203: 'Non-Authoritative Information',
+	204: 'No Content',
+	205: 'Reset Content',
+	206: 'Partial Content',
+	207: 'Multi-Status',
+	208: 'Already Reported',
+	226: 'IM Used',
+
+	// Redirections:
+	300: 'Multiple Choices',
+	301: 'Moved Permanently',
+	302: 'Found',
+	303: 'See Other',
+	304: 'Not Modified',
+	305: 'Use Proxy',
+	307: 'Temporary Redirect',
+	308: 'Permanent Redirect',
+
+	// Client Errors:
+	400: 'Bad Request',
+	401: 'Unauthorized',
+	402: 'Payment Required',
+	403: 'Forbidden',
+	404: 'Not Found',
+	405: 'Method Not Allowed',
+	406: 'Not Acceptable',
+	407: 'Proxy Authentication Required',
+	408: 'Request Timeout',
+	409: 'Conflict',
+	410: 'Gone',
+	411: 'Length Required',
+	412: 'Precondition Failed',
+	413: 'Payload Too Large',
+	414: 'URI Too Long',
+	415: 'Unsupported Media Type',
+	416: 'Range Not Satisfiable',
+	417: 'Expectation Failed',
+	418: 'I\'m a teapot',
+	421: 'Misdirected Request',
+	422: 'Unprocessable Entity',
+	423: 'Locked',
+	424: 'Failed Dependency',
+	425: 'Too Early',
+	426: 'Upgrade Required',
+	428: 'Precondition Required',
+	429: 'Too Many Requests',
+	431: 'Request Header Fields Too Large',
+	451: 'Unavailable For Legal Reasons',
+
+	// Server Errors:
+	500: 'Internal Server Error',
+	501: 'Not Implemented',
+	502: 'Bad Gateway',
+	503: 'Service Unavailable',
+	504: 'Gateway Timeout',
+	505: 'HTTP Version Not Supported',
+	506: 'Variant Also Negotiates',
+	507: 'Insufficient Storage',
+	508: 'Loop Detected',
+	510: 'Not Extended',
+	511: 'Network Authentication Required'
+};
+
+module.exports = {
+	descriptions: {
+		byCode: descriptionsByCode
+	},
+
+	symbols: {
+		byTag: symbolsByTag
+	}
+}

package/lib/{application/http → http}/request.js

@@ -7,14 +7,14 @@
 const accepts = require('accepts');
 const isIP = require('net').isIP;
 const typeis = require('type-is');
-const http = require('http');
+const { IncomingMessage } = require('http');
 const fresh = require('fresh');
 const parseRange = require('range-parser');
 const parse = require('parseurl');
 const proxyaddr = require('proxy-addr');
 
 
-const req = http.IncomingMessage.prototype;
+const req = IncomingMessage.prototype;
 
 module.exports = req;
 
@@ -355,39 +355,15 @@ defineGetter(req, 'path', function path() {
 
 /**
  * Parse the "Host" header field to a hostname.
- *
- * When the "trust proxy" setting trusts the socket
- * address, the "X-Forwarded-Host" header field will
- * be trusted.
+ * Will return  "X-Forwarded-Host" if set,
+ * or "Host" as a fallback.
  *
  * @return {String}
  * @public
  */
 defineGetter(req, 'hostname', function hostname() {
-	const trust = this.app.get('trust proxy fn');
-	let host = this.get('X-Forwarded-Host');
-
-	if (!host || !trust(this.connection.remoteAddress, 0)) {
-		host = this.get('Host');
-	}
-	else if (host.indexOf(',') !== -1) {
-		// Note: X-Forwarded-Host is normally only ever a
-		//       single value, but this is to be safe.
-		host = host.substring(0, host.indexOf(',')).trimRight()
-	}
-
-	if (!host)
-		return;
-
-	// IPv6 literal support
-	const offset = host[0] === '['
-		? host.indexOf(']') + 1
-		: 0;
-	const index = host.indexOf(':', offset);
-
-	return index !== -1
-		? host.substring(0, index)
-		: host;
+	const host = this.get('X-Forwarded-Host') ?? this.get('Host');
+	return host;
 });