nodester 0.0.1

package/lib/controllers/Controller.js

@@ -0,0 +1,474 @@
+// Constants.
+const VISITOR = 'visitor';
+// Data extractor:
+const Extractor = require('nodester/models/Extractor');
+// Preprocessors:
+const QueryPreprocessor = require('nodester/preprocessors/QueryPreprocessor');
+const BodyPreprocessor = require('nodester/preprocessors/BodyPreprocessor');
+// Reponse protocol generator.
+const APIResponseFactory = require('nodester/factories/responses/api');
+// Custom error.
+const { Err } = require('nodester/factories/errors');
+
+
+module.exports = class Controller {
+	constructor({
+		modelFacade,
+
+		queryPreprocessor,
+		bodyPreprocessor,
+
+		apiResponseFactory,
+
+		// Options.
+		withFiles,
+	}) {
+		if (!modelFacade) {
+			throw new Error('"modelFacade" argument is invalid.');
+		}
+		
+		// Main model.
+		const model = modelFacade?.model;
+		
+		// Set main services & utils:
+		this.extractor = new Extractor(model, { withFiles: !!withFiles });
+		this.facade = modelFacade;
+
+		// Set preprocessors:
+		// TODO: includes preprocessor.
+		this.queryPreprocessor = queryPreprocessor ?? new QueryPreprocessor();
+		this.bodyPreprocessor = bodyPreprocessor ?? null;
+
+		// Extract plural name of model.
+		const modelPluralName = model?.options?.name?.plural;
+		// Set private name of this controller.
+		this.name = `${modelPluralName ?? '_INVALID_NAME_'}Controller`;
+		
+		// Init standard API response factory.
+		const standardAPIResponseFactory = new APIResponseFactory();
+		// Set response factory:
+		this.createOKResponse = apiResponseFactory?.createOKResponse ?? 
+														standardAPIResponseFactory.createOKResponse.bind(standardAPIResponseFactory);
+		this.createErrorResponse = apiResponseFactory?.createErrorResponse ??
+															 standardAPIResponseFactory.createErrorResponse.bind(standardAPIResponseFactory);
+	}
+
+	processError(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.createErrorResponse({
+			res,
+			error: {
+				...errorResponse,
+				code: statusCode
+			},
+			status: statusCode
+		});
+	}
+
+	/* POST: */
+	async createOne(req, res) {
+		try {
+			// Extract all required info:
+			const {
+				// query,
+				includes
+			} = await this.extractQuery(req, res);
+
+			// Extract request's body.
+			const { body } = await this.extractBody(req, res);
+
+			// Extract new instance data.
+			const data = this.extractor.extractInstanceDataFromObject(
+										body,
+										includes,
+										{
+											skipIdValidation: true
+										});
+
+			const result = await this.facade.createOne({ data, includes });
+
+			// Hook.
+			await this.afterCreateOne(req, res, result);
+			
+			return this.createOKResponse({
+				res, 
+				content: { ...result }
+			});
+		}
+		catch(error) {
+			console.error(`${ this.name }.createOne error:`, error);
+			return this.processError(error, req, res);
+		}
+	}
+	/* POST\ */
+
+	/* GET: */
+	async getOne(req, res) {
+		try {
+			// Extract all required info:
+			const {
+				query,
+				includes
+			} = await this.extractQuery(req, res);
+
+			const params = {
+				query,
+				includes,
+			}
+
+			// If Query or Params contains main identifier (id),
+			// validate it:
+			if (!!query.id) {
+				// Extract main identifier.
+				const { id } = this.extractor.extractInstanceDataFromObject(
+												query,
+												null,
+												{
+													skipValidation: true
+												});
+				params.id = id;
+			}
+			// If Request's Params contains main identifier (id),
+			// validate it:
+			else if (!!req.params.id) {
+				// Extract main identifier.
+				const { id } = this.extractor.extractInstanceDataFromObject(
+												req.params,
+												null,
+												{
+													skipValidation: true
+												});
+				params.id = id;
+			}
+
+			const result = await this.facade.getOne(params);
+
+			return this.createOKResponse({
+				res, 
+				content: { ...result }
+			});
+		}
+		catch(error) {
+			console.error(`${ this.name }.getOne error:`, error);
+			return this.processError(error, req, res);
+		}
+	}
+
+	async getMany(req, res) {
+		try {
+			// Extract all required info:
+			const {
+				query,
+				includes
+			} = await this.extractQuery(req, res);
+
+			const params = {
+				query,
+				includes,
+			}
+
+			// If Query contains main identifier (id),
+			// validate it:
+			if (!!query.id) {
+				// Extract main identifier.
+				const { id } = this.extractor.extractInstanceDataFromObject(
+												query,
+												null,
+												{
+													skipValidation: true
+												});
+				params.query.id = id;
+			}
+			// If Request's Params contains main identifier (id),
+			// validate it:
+			else if (!!req.params.id) {
+				// Extract main identifier.
+				const { id } = this.extractor.extractInstanceDataFromObject(
+												req.params,
+												null,
+												{
+													skipValidation: true
+												});
+				params.query.id = id;
+			}
+
+			const result = await this.facade.getMany(params);
+
+			return this.createOKResponse({
+				res, 
+				content: { ...result }
+			});
+		}
+		catch(error) {
+			console.error(`${ this.name }.getMany error:`, error);
+			return this.processError(error, req, res);
+		}
+	}
+	/* GET\ */
+
+	/* PUT: */
+	async updateOne(req, res) {
+		try {
+			// Extract all required info:
+			const {
+				query,
+				includes
+			} = await this.extractQuery(req, res);
+
+			// Extract request's body.
+			const { body } = await this.extractBody(req, res);
+
+			// Init facade params.
+			const facadeParams = {
+				query,
+				includes,
+			};
+
+			// If request params contain main identifier (id),
+			// extract & validate it:
+			if (!!req.params.id) {
+				// Extract main identifier.
+				facadeParams.query.id = parseInt(req.params.id);
+			}
+			// If Query contains main identifier (id),
+			// validate it:
+			else if (!!query.id) {
+				// Extract main identifier.
+				const { id } = this.extractor.extractInstanceDataFromObject(
+												query,
+												null,
+												{
+													skipValidation: true
+												});
+				facadeParams.query.id = id;
+			}
+			// Extract instance data.
+			const data = this.extractor.extractInstanceDataFromObject(
+										body,
+										includes,
+										{
+											skipIdValidation: true,
+											skipValidation: true
+										});
+			facadeParams.data = data;
+
+			const result = await this.facade.updateOne(facadeParams);
+
+			// Hook.
+			await this.afterUpdateOne(req, res, result);
+			
+			return this.createOKResponse({
+				res, 
+				content: { ...result }
+			});
+		}
+		catch(error) {
+			console.error(`${ this.name }.updateOne error:`, error);
+			return this.processError(error, req, res);
+		}
+	}
+
+	/* ! Warning !
+	 * Unfinished method
+	 * Do not use!
+	 */
+	async updateMany(req, res) {
+		try {
+			// Extract all required info:
+			const {
+				query,
+				includes
+			} = await this.extractQuery(req, res);
+
+			// If Query contains main identifier (id),
+			// extract & validate it:
+			if (!!query.id) {
+				// Extract main identifier.
+				const { id } = this.extractor.extractInstanceDataFromObject(
+												query,
+												null,
+												{
+													skipValidation: true
+												});
+				query.id = id;
+			}
+			
+			// Extract data array:
+			const data = this.extractor.extractArrayDataFromObject(
+										req.body,
+										{
+											skipIdValidation: true,
+											skipValidation: true
+										});
+
+			console.log("Controller.updateMany", { data });
+
+			// TODO: Finish procedure
+			return;
+			// const result = await this.facade.updateMany({ data, includes });
+
+			// return this.createOKResponse({
+			// 	res,
+			// 	content: { ...result }
+			// });
+		}
+		catch(error) {
+			console.error(`${ this.name }.updateMany error:`, error);
+			return this.processError(error, req, res);
+		}
+	}
+	/* PUT\ */
+
+	/* DELETE: */
+	async deleteOne(req, res) {
+		try {
+			// Extract main identifier.
+			const { id } = this.extractor.extractInstanceDataFromObject(
+											req.params,
+											null,
+											{
+												skipValidation: true
+											});
+
+			const result = await this.facade.deleteOne({ id });
+
+			// Hook.
+			await this.afterDeleteOne(req, res, result);
+			
+			return this.createOKResponse({
+				res, 
+				content: { ...result }
+			});
+		}
+		catch(error) {
+			console.error(`${ this.name }.deleteOne error:`, error);
+			return this.processError(error, req, res);
+		}
+	}
+	/* DELETE\ */
+
+	/*
+	 * Hooks:
+	 */
+	async afterCreateOne(
+		req, res,
+		facadeResult
+	) {
+		// This method is empty, as it should be overwritten.
+		const content = { ...facadeResult };
+		return Promise.resolve(content);
+	}
+
+	async afterUpdateOne(
+		req, res,
+		facadeResult
+	) {
+		// This method is empty, as it should be overwritten.
+		const content = { ...facadeResult };
+		return Promise.resolve(content);
+	}
+
+	async afterDeleteOne(
+		req, res,
+		facadeResult
+	) {
+		// This method is empty, as it should be overwritten.
+		const content = { ...facadeResult };
+		return Promise.resolve(content);
+	}
+	/*
+	 * Hooks\
+	 */
+
+	// Preprocessors:
+	async extractQuery(req, res) {
+		try {
+			// Extract role.
+			const role = req?.token?.parsed?.role ?? VISITOR;
+
+			// Extract query:
+			const query = await this.queryPreprocessor.extract(
+											req,
+											role,
+										);
+			const { includes } = req.query;
+
+			return Promise.resolve({
+				query,
+				includes,
+			});
+		}
+		catch(error) {
+			return Promise.reject(error);
+		}
+	}
+
+	async extractBody(req, res, externalBodyObject=null) {
+		try {
+			// Extract role.
+			const role = req?.token?.parsed?.role ?? VISITOR;
+
+			// Extract body:
+			let body = externalBodyObject ?? req.body;
+
+			if (!!this.bodyPreprocessor) {
+				body = await this.bodyPreprocessor.extract(
+												req,
+												role,
+											);
+			}
+
+			return Promise.resolve({
+				body,
+			});
+		}
+		catch(error) {
+			return Promise.reject(error);
+		}
+	}
+	// Preprocessors\
+}

package/lib/controllers/JWTController.js

@@ -0,0 +1,240 @@
+// Boilerplate JWT facade.
+const standardJWTFacade = require('nodester/facades/jwt.facade');
+// Data extractor:
+const Extractor = require('nodester/models/Extractor');
+// Reponse protocol generator.
+const APIResponseFactory = require('nodester/factories/responses/api');
+// Utils:
+const { lowerCase } = require('nodester/utils/strings.util');
+const Params = require('nodester/utils/params.util');
+
+
+module.exports = class JWTController {
+	constructor({
+		jwtFacade,
+		apiResponseFactory,
+	}) {
+
+		this.facade = jwtFacade ?? standardJWTFacade;
+		this.name = 'JWTController';
+
+		// Init standard API response factory.
+		const standardAPIResponseFactory = new APIResponseFactory();
+		
+		// Set response factory:
+		this.createOKResponse = apiResponseFactory?.createOKResponse ?? 
+														standardAPIResponseFactory.createOKResponse.bind(standardAPIResponseFactory);
+		this.createErrorResponse = apiResponseFactory?.createErrorResponse ??
+															 standardAPIResponseFactory.createErrorResponse.bind(standardAPIResponseFactory);
+	}
+
+	processError(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 = 406;
+				errorResponse.details = { message: 'Email or password are incorrect.' };
+				break;
+			}
+			case('ValidationError'): {
+				statusCode = 402;
+				errorResponse.details = { message: 'Invalid email OR password input.' };
+				break;
+			}
+			case('InvalidToken'): {
+				statusCode = 401;
+				errorResponse.details = { message: 'Invalid token or token expired.' };
+				break;
+			}
+			case('UserNotFound'): {
+				statusCode = 400;
+				errorResponse.details = { message: "Such user doesn't exist." };
+				break;
+			}
+			default: {
+				errorResponse.details = { message: 'Could not process request.' };
+				break;
+			}
+		}
+
+		// Send error response with provided status code.
+		return this.createErrorResponse({
+			res,
+			error: {
+				...errorResponse,
+				code: statusCode
+			},
+			status: statusCode
+		});
+	}
+
+	async login(req, res) {
+		try {
+			// Extract request input:
+			const {
+				email,
+				password,
+				role,
+			} = Params(req.body, {
+				email: null,
+				password: null,
+				role: 'user',
+			});
+
+			if (!email|| !password) {
+				// If bad input, throw ValidationError:
+				const err = new Error('Invalid email OR password input');
+				err.name = 'ValidationError';
+				throw err;
+			}
+
+			// Lowercase email.
+			const _email = lowerCase(email);
+
+			const params = {
+				email: _email,
+				password,
+				role
+			};
+			const result = await this.facade.login(params);
+
+			// Everything's fine, send response.
+			return this.createOKResponse({
+				res, 
+				content: { ...result }
+			});
+		}
+		catch(error) {
+			console.error(`${ this.name }.login error:`, error);
+			return this.processError(error, req, res);
+		}
+	}
+
+	async validate(req, res) {
+		try {
+			const token = this.facade.service.extractTokenFromRequest(req);
+
+			// Validate token against local seed.
+			await this.facade.service.verifyAccessToken(token);
+
+			// Everything's fine, send response.
+			return this.createOKResponse({
+				res,
+				content: {
+					isValid: true,
+					message: "Valid Token"
+				}
+			});
+		}
+		catch(error) {
+			console.error("JWTController.validate error: ", error);
+
+			// In any error case, we send token not valid:
+			// Create custom error with name InvalidToken.
+			const err = new Error('Invalid Token!');
+			err.name = 'InvalidToken';
+			return this.processError(err, req, res);
+		}
+	}
+
+	async refresh(req, res) {
+		try {
+			const refreshToken = this.facade.service.extractRefreshTokenFromRequest(req);
+
+			// Validate token against local seed.
+			const parsedToken = await this.facade.service.verifyRefreshToken(refreshToken);
+
+			// Everything's ok, issue new one.
+			const accessToken = await this.facade.refreshAccessToken({
+																	refreshToken: refreshToken,
+																	parsedRefreshToken: parsedToken
+																});
+
+			return this.createOKResponse({
+				res,
+				content: {
+					token: accessToken 
+				}
+			});
+		}
+		catch(error) {
+			console.error(`${ this.name }.refresh error:`, error);
+
+			// In any error case, we send token not valid:
+			// Create custom error with name InvalidToken.
+			const err = new Error('Invalid Token!');
+			err.name = 'InvalidToken';
+			return this.processError(err, req, res);
+		}
+	}
+
+	async disableRefreshToken(req, res) {
+		try {
+			const refreshToken = this.facade.service.extractRefreshTokenFromRequest(req);
+
+			// Validate refreshToken against local seed.
+			const parsedToken = await this.facade.service.verifyRefreshToken(refreshToken);
+
+			const createdStatus = await this.facade.disableRefreshToken({ refreshToken, parsedToken });
+
+			return this.createOKResponse({
+				res,
+				content: {
+					success: createdStatus,
+					disabled: createdStatus
+				}
+			});
+		}
+		catch(error) {
+			console.error(`${ this.name }.disableRefreshToken error:`, error);
+			
+			// In any error case, we send token not valid:
+			// Create custom error with name InvalidToken.
+			const err = new Error('Invalid Token!');
+			err.name = 'InvalidToken';
+			return this.processError(err, req, res);
+		}
+	}
+
+	async logout(req, res) {
+		try {
+			const refreshToken = this.facade.service.extractRefreshTokenFromRequest(req);
+
+			if (!refreshToken) {
+				const err = new Error('No refreshToken found');
+				err.name = 'Unauthorized';
+				err.status = 401;
+				throw err;
+			}
+
+			// Verifys and parses token. On failed validation will throw error.
+			const parsedToken = await this.facade.service.verifyRefreshToken(refreshToken);
+
+			// Everything's ok, destroy token.
+			const { status } = await this.facade.disableRefreshToken({ refreshToken, parsedToken });
+
+			return this.createOKResponse({
+				res, 
+				content: {
+					status: status,
+					loggedIn: status === true
+				}
+			});
+		}
+		catch(error) {
+			console.error(`${ this.name }.logout error:`, error);
+			
+			// In any error case, we send token not valid:
+			// Create custom error with name InvalidToken.
+			const err = new Error('Invalid Token!');
+			err.name = 'InvalidToken';
+			return this.processError(err, req, res);
+		}
+	}
+}