@harperfast/harper 5.0.0-alpha.10 → 5.0.0-beta.3

package/validation/readLogValidator.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const envMangr = require('../utility/environment/environmentManager.js');
+const Joi = require('joi');
+const validator = require('./validationWrapper.js');
+const moment = require('moment');
+const fs = require('fs-extra');
+const path = require('path');
+const _ = require('lodash');
+const hdbTerms = require('../utility/hdbTerms.ts');
+const { LOG_LEVELS } = require('../utility/hdbTerms.ts');
+
+const LOG_DATE_FORMAT = 'YYYY-MM-DD hh:mm:ss';
+const INSTALL_LOG_LOCATION = path.resolve(__dirname, `../logs`);
+
+module.exports = function (object) {
+	return validator.validateBySchema(object, readLogSchema);
+};
+
+const readLogSchema = Joi.object({
+	from: Joi.custom(validateDatetime),
+	until: Joi.custom(validateDatetime),
+	to: Joi.custom(validateDatetime),
+	level: Joi.valid(
+		LOG_LEVELS.NOTIFY,
+		LOG_LEVELS.FATAL,
+		LOG_LEVELS.ERROR,
+		LOG_LEVELS.WARN,
+		LOG_LEVELS.INFO,
+		LOG_LEVELS.DEBUG,
+		LOG_LEVELS.TRACE
+	),
+	order: Joi.valid('asc', 'desc'),
+	limit: Joi.number().min(1),
+	start: Joi.number().min(0),
+	log_name: Joi.custom(validateReadLogPath),
+	filter: Joi.string(),
+});
+
+function validateDatetime(value, helpers) {
+	if (moment(value, moment.ISO_8601).format(LOG_DATE_FORMAT) === 'Invalid date') {
+		return helpers.message(`'${helpers.state.path[0]}' date '${value}' is invalid.`);
+	}
+}
+
+function validateReadLogPath(value, helpers) {
+	const processLogName = _.invert(hdbTerms.LOG_NAMES);
+	if (processLogName[value] === undefined) {
+		return helpers.message(`'log_name' '${value}' is invalid.`);
+	}
+
+	const logPath = envMangr.get(hdbTerms.HDB_SETTINGS_NAMES.LOG_PATH_KEY);
+	const logName = value === undefined ? hdbTerms.LOG_NAMES.HDB : value;
+	const readLogPath =
+		logName === hdbTerms.LOG_NAMES.INSTALL
+			? path.join(INSTALL_LOG_LOCATION, hdbTerms.LOG_NAMES.INSTALL)
+			: path.join(logPath, logName);
+
+	let exists = fs.existsSync(readLogPath);
+	if (exists) {
+		return null;
+	}
+	return helpers.message(`'log_name' '${value}' does not exist.`);
+}

package/validation/role_validation.js

@@ -0,0 +1,320 @@
+const validate = require('validate.js'),
+	validator = require('./validationWrapper.js'),
+	terms = require('../utility/hdbTerms.ts'),
+	{ validateOperations } = require('../utility/operationPermissions.ts'),
+	{ handleHDBError, hdbErrors } = require('../utility/errors/hdbError.js');
+
+const { HDB_ERROR_MSGS, HTTP_STATUS_CODES } = hdbErrors;
+
+const constraintsTemplate = () => ({
+	role: {
+		presence: true,
+		format: '[\\w\\-\\_]+',
+	},
+	id: {
+		presence: true,
+		format: '[\\w\\-\\_]+',
+	},
+	permission: {
+		presence: true,
+	},
+});
+
+const STRUCTURE_USER_ENUM = {
+	STRUCTURE_USER: 'structure_user',
+};
+
+const OPERATIONS_KEY = 'operations';
+
+const ROLE_TYPES = Object.values(terms.ROLE_TYPES_ENUM);
+const ATTR_PERMS_KEY = 'attribute_permissions';
+const ATTR_NAME_KEY = 'attribute_name';
+const { PERMS_CRUD_ENUM } = terms;
+const TABLE_PERM_KEYS = [ATTR_PERMS_KEY, ...Object.values(PERMS_CRUD_ENUM)];
+const ATTR_CRU_KEYS = [PERMS_CRUD_ENUM.READ, PERMS_CRUD_ENUM.INSERT, PERMS_CRUD_ENUM.UPDATE];
+const ATTR_PERMS_KEYS = [ATTR_NAME_KEY, ...ATTR_CRU_KEYS];
+
+function addRoleValidation(object) {
+	const constraints = constraintsTemplate();
+	constraints.role.presence = true;
+	constraints.id.presence = false;
+	constraints.permission.presence = true;
+	return customValidate(object, constraints);
+}
+
+function alterRoleValidation(object) {
+	const constraints = constraintsTemplate();
+	constraints.role.presence = false;
+	constraints.id.presence = true;
+	constraints.permission.presence = true;
+	return customValidate(object, constraints);
+}
+
+function dropRoleValidation(object) {
+	const constraints = constraintsTemplate();
+	constraints.role.presence = false;
+	constraints.id.presence = true;
+	constraints.permission.presence = false;
+	return validator.validateObject(object, constraints);
+}
+
+const ALLOWED_JSON_KEYS = ['operation', 'role', 'id', 'permission', 'hdb_user', 'access'];
+
+function customValidate(object, constraints) {
+	let validationErrors = {
+		main_permissions: [],
+		schema_permissions: {},
+	};
+
+	const jsonMsgKeys = Object.keys(object);
+
+	//Check to confirm that keys in JSON body are valid
+	const invalidKeys = [];
+	for (let i = 0, arrLength = jsonMsgKeys.length; i < arrLength; i++) {
+		if (!ALLOWED_JSON_KEYS.includes(jsonMsgKeys[i])) {
+			invalidKeys.push(jsonMsgKeys[i]);
+		}
+	}
+	if (invalidKeys.length > 0) {
+		addPermError(HDB_ERROR_MSGS.INVALID_ROLE_JSON_KEYS(invalidKeys), validationErrors);
+	}
+
+	let validateResult = validator.validateObject(object, constraints);
+	if (validateResult) {
+		validateResult.message.split(',').forEach((validationErr) => {
+			addPermError(validationErr, validationErrors);
+		});
+	}
+
+	//need this check to avoid unexpected errors if someone doesn't have permissions key included in request
+	if (object.permission) {
+		//check if role is SU or CU and has perms included
+		const suPermsError = validateNoSUPerms(object);
+		if (suPermsError) {
+			addPermError(suPermsError, validationErrors);
+		}
+		//check if cu or su values, if included, are booleans
+		ROLE_TYPES.forEach((role) => {
+			if (object.permission[role] && !validate.isBoolean(object.permission[role])) {
+				addPermError(HDB_ERROR_MSGS.SU_CU_ROLE_BOOLEAN_ERROR(role), validationErrors);
+			}
+		});
+	}
+
+	for (let item in object.permission) {
+		if (ROLE_TYPES.indexOf(item) < 0) {
+			//validate the user type 'structure_user'.  acceptable data type is boolean or array of strings (this would be array of accepted schemas to interact with)
+			if (item === STRUCTURE_USER_ENUM.STRUCTURE_USER) {
+				let structureUserPerm = object.permission[item];
+
+				//boolean is valid, move on
+				if (typeof structureUserPerm === 'boolean') {
+					continue;
+				}
+
+				//array is valid check to make sure each entry is actually a schema.
+				if (Array.isArray(structureUserPerm)) {
+					for (let k = 0, length = structureUserPerm.length; k < length; k++) {
+						let schemaPerm = structureUserPerm[k];
+						if (!global.hdb_schema[schemaPerm]) {
+							addPermError(HDB_ERROR_MSGS.SCHEMA_NOT_FOUND(schemaPerm), validationErrors);
+						}
+					}
+					continue;
+				}
+
+				//if we end up here then this is an invalid data type
+				addPermError(HDB_ERROR_MSGS.STRUCTURE_USER_ROLE_TYPE_ERROR(item), validationErrors);
+				continue;
+			}
+
+			// validate operations: must be an array of valid operation names and/or group names
+			if (item === OPERATIONS_KEY) {
+				const opUserPerm = object.permission[item];
+
+				if (!Array.isArray(opUserPerm)) {
+					addPermError(HDB_ERROR_MSGS.OPERATIONS_MUST_BE_ARRAY, validationErrors);
+					continue;
+				}
+
+				const invalidOp = validateOperations(opUserPerm);
+				if (invalidOp !== null) {
+					addPermError(HDB_ERROR_MSGS.INVALID_OPERATIONS_OP(invalidOp), validationErrors);
+				}
+				continue;
+			}
+
+			let schema = object.permission[item];
+			//validate that schema exists
+			if (!item || !global.hdb_schema[item]) {
+				addPermError(HDB_ERROR_MSGS.SCHEMA_NOT_FOUND(item), validationErrors);
+				continue;
+			}
+			if (schema.tables) {
+				for (let t in schema.tables) {
+					let table = schema.tables[t];
+					//validate that table exists in schema
+					if (!t || !global.hdb_schema[item][t]) {
+						addPermError(HDB_ERROR_MSGS.TABLE_NOT_FOUND(item, t), validationErrors);
+						continue;
+					}
+
+					//validate all table perm keys are valid
+					Object.keys(table).forEach((tableKey) => {
+						if (!TABLE_PERM_KEYS.includes(tableKey)) {
+							addPermError(HDB_ERROR_MSGS.INVALID_PERM_KEY(tableKey), validationErrors, item, t);
+						}
+					});
+
+					//validate table CRUD perms
+					Object.values(PERMS_CRUD_ENUM).forEach((permKey) => {
+						if (!validate.isDefined(table[permKey])) {
+							addPermError(HDB_ERROR_MSGS.TABLE_PERM_MISSING(permKey), validationErrors, item, t);
+						} else if (!validate.isBoolean(table[permKey])) {
+							addPermError(HDB_ERROR_MSGS.TABLE_PERM_NOT_BOOLEAN(permKey), validationErrors, item, t);
+						}
+					});
+
+					//validate table ATTRIBUTE_PERMISSIONS perm
+					if (table.attribute_permissions === undefined) {
+						addPermError(HDB_ERROR_MSGS.ATTR_PERMS_ARRAY_MISSING, validationErrors, item, t);
+						continue;
+					} else if (!(Array.isArray(table.attribute_permissions) || table.attribute_permissions === null)) {
+						addPermError(HDB_ERROR_MSGS.ATTR_PERMS_NOT_ARRAY, validationErrors, item, t);
+						continue;
+					}
+
+					//need this check here to ensure no unexpected errors if key is missing in table perms obj
+					if (table.attribute_permissions) {
+						let tableAttributeNames = global.hdb_schema[item][t].attributes.map(({ attribute }) => attribute);
+						const attrPermsCheck = {
+							read: false,
+							insert: false,
+							update: false,
+						};
+
+						for (let r in table.attribute_permissions) {
+							let permission = table.attribute_permissions[r];
+
+							Object.keys(permission).forEach((key) => {
+								//Leaving this second check for "DELETE" in for now since we've decided to silently
+								// allow it to remain in the attr permission object even though we do not use it
+								if (!ATTR_PERMS_KEYS.includes(key) && key !== PERMS_CRUD_ENUM.DELETE) {
+									addPermError(HDB_ERROR_MSGS.INVALID_ATTR_PERM_KEY(key), validationErrors, item, t);
+								}
+							});
+
+							//validate that attribute_name is included
+							if (!validate.isDefined(permission.attribute_name)) {
+								addPermError(HDB_ERROR_MSGS.ATTR_PERM_MISSING_NAME, validationErrors, item, t);
+								continue;
+							}
+
+							const attrName = permission.attribute_name;
+							//validate that attr exists in schema for table
+							if (!tableAttributeNames.includes(attrName)) {
+								addPermError(HDB_ERROR_MSGS.INVALID_ATTRIBUTE_IN_PERMS(attrName), validationErrors, item, t);
+								continue;
+							}
+
+							//validate table attribute CRU perms
+							ATTR_CRU_KEYS.forEach((permKey) => {
+								if (!validate.isDefined(permission[permKey])) {
+									addPermError(HDB_ERROR_MSGS.ATTR_PERM_MISSING(permKey, attrName), validationErrors, item, t);
+								} else if (!validate.isBoolean(permission[permKey])) {
+									addPermError(HDB_ERROR_MSGS.ATTR_PERM_NOT_BOOLEAN(permKey, attrName), validationErrors, item, t);
+								}
+							});
+
+							//confirm that false table perms are not set to true for an attribute
+							if (!attrPermsCheck.read && permission.read === true) {
+								attrPermsCheck.read = true;
+							}
+							if (!attrPermsCheck.insert && permission.insert === true) {
+								attrPermsCheck.insert = true;
+							}
+							if (!attrPermsCheck.update && permission.update === true) {
+								attrPermsCheck.update = true;
+							}
+						}
+						//validate that there is no mismatching perms between table and attrs
+						if (
+							(table.read === false && attrPermsCheck.read === true) ||
+							(table.insert === false && attrPermsCheck.insert === true) ||
+							(table.update === false && attrPermsCheck.update === true)
+						) {
+							const schemaName = `${item}.${t}`;
+							addPermError(HDB_ERROR_MSGS.MISMATCHED_TABLE_ATTR_PERMS(schemaName), validationErrors, item, t);
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return generateRolePermResponse(validationErrors);
+}
+
+module.exports = {
+	addRoleValidation,
+	alterRoleValidation,
+	dropRoleValidation,
+};
+
+/**
+ * Validates that permissions object for CU or SU roles do not also include permissions
+ * @param obj
+ * @returns {string|null}
+ */
+function validateNoSUPerms(obj) {
+	const { operation, permission } = obj;
+	if (operation === terms.OPERATIONS_ENUM.ADD_ROLE || operation === terms.OPERATIONS_ENUM.ALTER_ROLE) {
+		//Check if role type is super user
+		const isSuRole = permission.super_user === true;
+		const hasPerms = Object.keys(permission).length > 1;
+		if (hasPerms && isSuRole) {
+			return HDB_ERROR_MSGS.SU_CU_ROLE_NO_PERMS_ALLOWED(terms.ROLE_TYPES_ENUM.SUPER_USER);
+		}
+	}
+	return null;
+}
+
+/**
+ * Builds final permissions object error response to return if validation fails
+ *
+ * @param validationErrors
+ * @returns {null|HdbError}
+ */
+function generateRolePermResponse(validationErrors) {
+	const { main_permissions, schema_permissions } = validationErrors;
+	if (main_permissions.length > 0 || Object.keys(schema_permissions).length > 0) {
+		let validationMessage = {
+			error: HDB_ERROR_MSGS.ROLE_PERMS_ERROR,
+			...validationErrors,
+		};
+
+		return handleHDBError(new Error(), validationMessage, HTTP_STATUS_CODES.BAD_REQUEST);
+	} else {
+		return null;
+	}
+}
+
+/**
+ * Adds perm validation error to the correct category for the final validation error response
+ * @param err
+ * @param invalidPermsObj
+ * @param schema
+ * @param table
+ */
+function addPermError(err, invalidPermsObj, schema, table) {
+	if (!schema) {
+		invalidPermsObj.main_permissions.push(err);
+	} else {
+		const schemaKey = table ? schema + '_' + table : schema;
+		if (!invalidPermsObj.schema_permissions[schemaKey]) {
+			invalidPermsObj.schema_permissions[schemaKey] = [err];
+		} else {
+			invalidPermsObj.schema_permissions[schemaKey].push(err);
+		}
+	}
+}

package/validation/schemaMetadataValidator.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const schemaDescribe = require('../dataLayer/schemaDescribe.js');
+const { hdbErrors } = require('../utility/errors/hdbError.js');
+const { getDatabases } = require('../resources/databases.ts');
+
+module.exports = {
+	checkSchemaExists,
+	checkSchemaTableExists,
+	schemaDescribe,
+};
+
+/**
+ * Checks the global hdbSchema for a schema and table
+ * @param schemaName
+ * @param tableName
+ * @returns string returns a thrown message if schema and or table does not exist
+ */
+async function checkSchemaExists(schemaName) {
+	let databases = getDatabases();
+	if (!databases[schemaName]) {
+		return hdbErrors.HDB_ERROR_MSGS.SCHEMA_NOT_FOUND(schemaName);
+	}
+}
+
+/**
+ * Checks the global hdbSchema for a schema and table
+ * @param schemaName
+ * @param tableName
+ * @returns string returns a thrown message if schema and or table does not exist
+ */
+async function checkSchemaTableExists(schemaName, tableName) {
+	let invalidSchema = await checkSchemaExists(schemaName);
+	if (invalidSchema) {
+		return invalidSchema;
+	}
+	let databases = getDatabases();
+
+	if (!databases[schemaName][tableName]) {
+		return hdbErrors.HDB_ERROR_MSGS.TABLE_NOT_FOUND(schemaName, tableName);
+	}
+}

package/validation/searchValidator.js

@@ -0,0 +1,166 @@
+const _ = require('lodash'),
+	validator = require('./validationWrapper.js');
+const Joi = require('joi');
+const hdbUtils = require('../utility/common_utils.js');
+const { hdbSchemaTable, checkValidTable, hdbTable, hdbDatabase } = require('./common_validators.js');
+const { handleHDBError, hdbErrors } = require('../utility/errors/hdbError.js');
+const { getDatabases } = require('../resources/databases.ts');
+const { HTTP_STATUS_CODES } = hdbErrors;
+
+const searchByValueSchema = Joi.object({
+	database: hdbDatabase,
+	schema: hdbDatabase,
+	table: hdbTable,
+	attribute: hdbSchemaTable,
+	value: Joi.any().required(),
+	get_attributes: Joi.array().min(1).items(Joi.alternatives(hdbSchemaTable, Joi.object())).optional(),
+	desc: Joi.bool(),
+	limit: Joi.number().integer().min(1),
+	offset: Joi.number().integer().min(0),
+});
+
+const searchByConditionsSchema = Joi.object({
+	database: hdbDatabase,
+	schema: hdbDatabase,
+	table: hdbTable,
+	operator: Joi.string().valid('and', 'or').default('and').lowercase(),
+	offset: Joi.number().integer().min(0),
+	limit: Joi.number().integer().min(1),
+	get_attributes: Joi.array().min(1).items(Joi.alternatives(hdbSchemaTable, Joi.object())).optional(),
+	sort: Joi.object({
+		attribute: Joi.alternatives(hdbSchemaTable, Joi.array().min(1)),
+		descending: Joi.bool().optional(),
+	}).optional(),
+	conditions: Joi.array()
+		.min(1)
+		.items(
+			Joi.alternatives(
+				Joi.object({ operator: Joi.string().valid('and', 'or').default('and').lowercase(), conditions: Joi.array() }),
+				Joi.object({
+					attribute: Joi.alternatives(hdbSchemaTable, Joi.array().min(1)),
+					comparator: Joi.string()
+						.valid(
+							'equals',
+							'contains',
+							'starts_with',
+							'ends_with',
+							'greater_than',
+							'greater_than_equal',
+							'less_than',
+							'less_than_equal',
+							'between',
+							'not_equal'
+						)
+						.optional(),
+					value: Joi.when('comparator', {
+						switch: [
+							{ is: 'equals', then: Joi.any() },
+							{
+								is: 'between',
+								then: Joi.array()
+									.items(Joi.alternatives([Joi.string(), Joi.number()]))
+									.length(2),
+							},
+						],
+						otherwise: Joi.alternatives(Joi.string(), Joi.number()),
+					}).required(),
+				})
+			)
+		)
+		.required(),
+});
+
+module.exports = function (searchObject, type) {
+	let validationError = null;
+	switch (type) {
+		case 'value':
+			validationError = validator.validateBySchema(searchObject, searchByValueSchema);
+			break;
+		case 'hashes':
+			let errors;
+			addError(checkValidTable('database', searchObject.schema));
+			addError(checkValidTable('table', searchObject.table));
+			if (!searchObject.hash_values) addError(`'hash_values' is required`);
+			else if (!Array.isArray(searchObject.hash_values)) addError(`'hash_values' must be an array`);
+			else if (!searchObject.hash_values.every((value) => typeof value === 'string' || typeof value === 'number'))
+				addError(`'hash_values' must be strings or numbers`);
+			if (!searchObject.get_attributes) addError(`'get_attributes' is required`);
+			else if (!Array.isArray(searchObject.get_attributes)) addError(`'get_attributes' must be an array`);
+			else if (searchObject.get_attributes.length === 0) addError(`'get_attributes' must contain at least 1 item`);
+			else if (!searchObject.get_attributes.every((value) => typeof value === 'string' || typeof value === 'number'))
+				addError(`'get_attributes' must be strings or numbers`);
+			function addError(error) {
+				if (errors) errors += '. ' + error;
+				else errors = error;
+			}
+			if (errors) validationError = new Error(errors.trim());
+			break;
+		case 'conditions':
+			validationError = validator.validateBySchema(searchObject, searchByConditionsSchema);
+			break;
+		default:
+			throw new Error(`Error validating search, unknown type: ${type}`);
+	}
+
+	// validate table and attribute if format validation is valid
+	if (!validationError && searchObject.schema !== 'system') {
+		// skip validation for system schema
+		//check if schema.table does not exist throw error
+		let checkSchemaTable = hdbUtils.checkGlobalSchemaTable(searchObject.schema, searchObject.table);
+		if (checkSchemaTable) {
+			return handleHDBError(new Error(), checkSchemaTable, HTTP_STATUS_CODES.NOT_FOUND);
+		}
+
+		let tableSchema = getDatabases()[searchObject.schema][searchObject.table];
+		let allTableAttributes = tableSchema.attributes;
+
+		//this clones the get_attributes array
+		let checkAttributes = searchObject.get_attributes ? [...searchObject.get_attributes] : [];
+
+		if (type === 'value') {
+			checkAttributes.push(searchObject.attribute);
+		}
+
+		//if search type is conditions add conditions fields to see if the fields exist
+		const addConditions = (searchObject) => {
+			//this is used to validate condition attributes exist in the schema
+			for (const condition of searchObject.conditions) {
+				if (condition.conditions) addConditions(condition);
+				else checkAttributes.push(condition.attribute);
+			}
+		};
+		if (type === 'conditions') {
+			addConditions(searchObject);
+		}
+
+		let unknownAttributes = _.filter(
+			checkAttributes,
+			(attribute) =>
+				attribute !== '*' &&
+				!attribute.startsWith?.('$') && // meta attributes
+				attribute.attribute !== '*' && // skip check for asterisk attribute
+				!Array.isArray(attribute) &&
+				!attribute.name && // nested attribute
+				!_.some(
+					allTableAttributes,
+					(
+						tableAttribute // attribute should match one of the attribute in global
+					) =>
+						tableAttribute === attribute ||
+						tableAttribute.attribute === attribute ||
+						tableAttribute.attribute === attribute.attribute
+				)
+		);
+
+		// if any unknown attributes present in the search request then list all indicated as unknown attribute to error message at once split in well format
+		// for instance "unknown attribute a, b and c" or "unknown attribute a"
+		if (unknownAttributes && unknownAttributes.length > 0) {
+			// return error with proper message - replace last comma with and
+			let errorMsg = unknownAttributes.join(', ');
+			errorMsg = errorMsg.replace(/,([^,]*)$/, ' and$1');
+			return new Error(`unknown attribute '${errorMsg}'`);
+		}
+	}
+
+	return validationError;
+};

package/validation/statusValidator.ts

@@ -0,0 +1,66 @@
+import Joi from 'joi';
+import * as validator from './validationWrapper.js';
+import { STATUS_DEFINITIONS, STATUS_IDS, DEFAULT_STATUS_ID, type StatusId } from '../server/status/definitions.ts';
+
+// Re-export constants for backward compatibility
+export const STATUS_SCHEMAS = STATUS_DEFINITIONS;
+export const STATUS_ALLOWED = STATUS_IDS;
+export const STATUS_DEFAULT = DEFAULT_STATUS_ID;
+
+/**
+ * Pregenerate error messages to avoid repeated string concatenation
+ */
+const ERROR_MESSAGES = Object.entries(STATUS_DEFINITIONS).reduce(
+	(messages, [id, definition]) => {
+		if (definition.allowedValues) {
+			messages[id] = `Status "${id}" only accepts these values: ${definition.allowedValues.join(', ')}`;
+		}
+		return messages;
+	},
+	{} as Record<string, string>
+);
+
+/**
+ * Creates the status validation schema using the STATUS_DEFINITIONS
+ */
+const createStatusValidationSchema = () => {
+	// Start with base schema
+	let statusSchema = Joi.string().min(1).max(512);
+
+	// Add conditional validations for each status type that has allowedValues
+	(Object.entries(STATUS_DEFINITIONS) as [StatusId, (typeof STATUS_DEFINITIONS)[StatusId]][]).forEach(
+		([id, definition]) => {
+			if (definition.allowedValues) {
+				statusSchema = statusSchema.when('id', {
+					is: id,
+					then: Joi.string()
+						.valid(...definition.allowedValues)
+						.messages({
+							'any.only': ERROR_MESSAGES[id],
+						}),
+				});
+			}
+		}
+	);
+
+	return statusSchema.required();
+};
+
+/**
+ * Joi schema for validating status operations
+ */
+const setStatusSchema = Joi.object({
+	id: Joi.string()
+		.valid(...STATUS_ALLOWED)
+		.required(),
+	status: createStatusValidationSchema(),
+});
+
+/**
+ * Validates the status operation parameters
+ * @param obj The status operation parameters to validate
+ * @returns Error if validation fails, null otherwise
+ */
+export function validateStatus(obj: any) {
+	return validator.validateBySchema(obj, setStatusSchema);
+}

package/validation/transactionLogValidator.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const Joi = require('joi');
+const validator = require('./validationWrapper.js');
+
+module.exports = {
+	readTransactionLogValidator,
+	deleteTransactionLogsBeforeValidator,
+};
+
+function readTransactionLogValidator(req) {
+	const schema = Joi.object({
+		schema: Joi.string(),
+		database: Joi.string(),
+		table: Joi.string().required(),
+		from: Joi.date().timestamp(),
+		to: Joi.date().timestamp(),
+		limit: Joi.number().min(1),
+	});
+
+	return validator.validateBySchema(req, schema);
+}
+
+function deleteTransactionLogsBeforeValidator(req) {
+	const schema = Joi.object({
+		schema: Joi.string(),
+		database: Joi.string(),
+		table: Joi.string().required(),
+		timestamp: Joi.date().timestamp().required(),
+	});
+
+	return validator.validateBySchema(req, schema);
+}