@h3ravel/validation 0.1.0-alpha.1

package/dist/index.cjs

@@ -0,0 +1,648 @@
+let simple_body_validator = require("simple-body-validator");
+let __h3ravel_support = require("@h3ravel/support");
+let __h3ravel_foundation = require("@h3ravel/foundation");
+
+//#region src/ImplicitRule.ts
+var ImplicitRule = class extends simple_body_validator.ImplicitRule {
+	rules = [];
+};
+
+//#endregion
+//#region src/Providers/ValidationServiceProvider.ts
+/**
+* Service provider for Validation utilities
+*/
+var ValidationServiceProvider = class {
+	registeredCommands;
+	static priority = 895;
+	constructor(app) {
+		this.app = app;
+	}
+	/**
+	* Register URL services in the container
+	*/
+	register() {}
+	/**
+	* Boot URL services
+	*/
+	boot() {}
+};
+
+//#endregion
+//#region src/ValidationRule.ts
+var ValidationRule = class extends simple_body_validator.Rule {
+	rules = [];
+	passing = false;
+	/**
+	* Set the data under validation.
+	*/
+	setData(_data) {
+		return this;
+	}
+	passes(value, attribute) {
+		this.passing = true;
+		this.validate(attribute, value, (message) => {
+			this.message = message;
+			this.passing = false;
+		});
+		return this.passing;
+	}
+};
+
+//#endregion
+//#region src/Rules/ExtendedRules.ts
+var ExtendedRules = class extends ValidationRule {
+	/**
+	* The validator instance.
+	*/
+	validator;
+	setValidator(validator) {
+		this.validator = validator;
+		return this;
+	}
+	rules = [
+		{
+			name: "hex",
+			validator: (value) => {
+				if (typeof value !== "string") return false;
+				return /^[0-9a-fA-F]+$/.test(value.replace("#", ""));
+			},
+			message: "The :attribute must be a valid hexadecimal string."
+		},
+		{
+			name: "includes",
+			validator: (value, parameters = []) => {
+				if (value == null) return false;
+				if (Array.isArray(value)) return parameters.some((param) => value.includes(param));
+				if (typeof value === "string") return parameters.some((param) => value.includes(param));
+				return false;
+			},
+			message: "The :attribute must include one of the following values: :values."
+		},
+		{
+			name: "not_includes",
+			validator: (value, parameters = []) => {
+				if (value == null) return true;
+				if (Array.isArray(value)) return parameters.every((param) => !value.includes(param));
+				if (typeof value === "string") return parameters.every((param) => !value.includes(param));
+				return true;
+			},
+			message: "The :attribute must not include any of the following values: :values."
+		},
+		{
+			name: "datetime",
+			validator: (value, parameters = [], attr) => {
+				if (typeof value !== "string") return false;
+				const [format] = parameters;
+				if (!format) return !isNaN(Date.parse(value));
+				try {
+					return new __h3ravel_support.DateTime(value, format, true).isValid();
+				} catch {
+					return !isNaN(Date.parse(value));
+				}
+			},
+			message: "The :attribute must be a valid date matching the format :format."
+		},
+		{
+			name: "exists",
+			validator: async (value, parameters = []) => {
+				const [tab, column, ignore] = parameters;
+				try {
+					const { DB } = await import("@h3ravel/database");
+					const [conn, table] = tab.split(".");
+					const query = DB.instance(table && conn ? conn : "default").table(table && conn ? table : conn);
+					if (ignore) query.whereNot(column, ignore);
+					return await query.where(column, value).exists();
+				} catch {
+					return false;
+				}
+			},
+			message: "The :attribute does not exist."
+		},
+		{
+			name: "unique",
+			validator: async (value, parameters = []) => {
+				const [tab, column, ignore] = parameters;
+				try {
+					const { DB } = await import("@h3ravel/database");
+					const [conn, table] = tab.split(".");
+					const query = DB.instance(table && conn ? conn : "default").table(table && conn ? table : conn);
+					if (ignore) query.whereNot(column, ignore);
+					return !await query.where(column, value).exists();
+				} catch {
+					return false;
+				}
+			},
+			message: "The :attribute does not exist."
+		}
+	];
+	validate() {}
+};
+
+//#endregion
+//#region src/utilities/MessageBag.ts
+var MessageBag = class {
+	/**
+	* All of the registered messages.
+	*/
+	messages = {};
+	/**
+	* Default format for message output.
+	*/
+	format = ":message";
+	/**
+	* Create a new message bag instance.
+	*/
+	constructor(messages = {}) {
+		for (const [key, value] of Object.entries(messages)) {
+			const arr = Array.isArray(value) ? value : [value];
+			this.messages[key] = Array.from(new Set(arr));
+		}
+	}
+	/**
+	* Get all message keys.
+	*/
+	keys() {
+		return Object.keys(this.messages);
+	}
+	/**
+	* Add a message.
+	*/
+	add(key, message) {
+		if (this.isUnique(key, message)) {
+			if (!this.messages[key]) this.messages[key] = [];
+			this.messages[key].push(message);
+		}
+		return this;
+	}
+	/**
+	* Add a message conditionally.
+	*/
+	addIf(condition, key, message) {
+		return condition ? this.add(key, message) : this;
+	}
+	/**
+	* Check uniqueness of key/message pair.
+	*/
+	isUnique(key, message) {
+		return !this.messages[key] || !this.messages[key].includes(message);
+	}
+	/**
+	* Merge another message source into this one.
+	*/
+	merge(messages) {
+		const incoming = messages.getMessageBag?.()?.getMessages?.() ?? messages;
+		for (const [key, list] of Object.entries(incoming)) {
+			if (!this.messages[key]) this.messages[key] = [];
+			this.messages[key].push(...list);
+			this.messages[key] = Array.from(new Set(this.messages[key]));
+		}
+		return this;
+	}
+	/**
+	* Determine if messages exist for all given keys.
+	*/
+	has(key) {
+		if (this.isEmpty()) return false;
+		if (key == null) return this.any();
+		return (Array.isArray(key) ? key : [key]).every((k) => this.first(k) !== "");
+	}
+	/**
+	* Determine if messages exist for any given key.
+	*/
+	hasAny(keys = []) {
+		if (this.isEmpty()) return false;
+		return (Array.isArray(keys) ? keys : [keys]).some((k) => this.has(k));
+	}
+	/**
+	* Determine if messages don't exist for given keys.
+	*/
+	missing(key) {
+		const keys = Array.isArray(key) ? key : [key];
+		return !this.hasAny(keys);
+	}
+	/**
+	* Get the first message for a given key.
+	*/
+	first(key = null, format = null) {
+		const messages = key == null ? this.all(format) : this.get(key, format);
+		const firstMessage = Array.isArray(messages) ? messages[0] ?? "" : "";
+		return Array.isArray(firstMessage) ? firstMessage[0] ?? "" : firstMessage;
+	}
+	/**
+	* Get all messages for a given key.
+	*/
+	get(key, format = null) {
+		if (this.messages[key]) return this.transform(this.messages[key], this.checkFormat(format), key);
+		if (key.includes("*")) return this.getMessagesForWildcardKey(key, format);
+		return [];
+	}
+	/**
+	* Wildcard key match.
+	*/
+	getMessagesForWildcardKey(key, format) {
+		const regex = /* @__PURE__ */ new RegExp("^" + key.replace(/\*/g, ".*") + "$");
+		const result = {};
+		for (const [messageKey, messages] of Object.entries(this.messages)) if (regex.test(messageKey)) result[messageKey] = this.transform(messages, this.checkFormat(format), messageKey);
+		return result;
+	}
+	/**
+	* Get all messages.
+	*/
+	all(format = null) {
+		const fmt = this.checkFormat(format);
+		const all = [];
+		for (const [key, messages] of Object.entries(this.messages)) all.push(...this.transform(messages, fmt, key));
+		return all;
+	}
+	/**
+	* Get unique messages.
+	*/
+	unique(format = null) {
+		return Array.from(new Set(this.all(format)));
+	}
+	/**
+	* Remove messages for a key.
+	*/
+	forget(key) {
+		delete this.messages[key];
+		return this;
+	}
+	/**
+	* Format an array of messages.
+	*/
+	transform(messages, format, messageKey) {
+		if (format === ":message") return messages;
+		return messages.map((m) => format.replace(":message", m).replace(":key", messageKey));
+	}
+	/**
+	* Get proper format string.
+	*/
+	checkFormat(format) {
+		return format || this.format;
+	}
+	/**
+	* Get raw messages.
+	*/
+	messagesRaw() {
+		return this.messages;
+	}
+	/**
+	* Alias for messagesRaw().
+	*/
+	getMessages() {
+		return this.messagesRaw();
+	}
+	/**
+	* Return message bag instance.
+	*/
+	getMessageBag() {
+		return this;
+	}
+	/**
+	* Get format string.
+	*/
+	getFormat() {
+		return this.format;
+	}
+	/**
+	* Set default message format.
+	*/
+	setFormat(format = ":message") {
+		this.format = format;
+		return this;
+	}
+	/**
+	* Empty checks.
+	*/
+	isEmpty() {
+		return !this.any();
+	}
+	isNotEmpty() {
+		return this.any();
+	}
+	any() {
+		return this.count() > 0;
+	}
+	/**
+	* Count total messages.
+	*/
+	count() {
+		return Object.values(this.messages).reduce((sum, list) => sum + list.length, 0);
+	}
+	/**
+	* Array & JSON conversions.
+	*/
+	toArray() {
+		return this.getMessages();
+	}
+	jsonSerialize() {
+		return this.toArray();
+	}
+	toJson(options = 0) {
+		return JSON.stringify(this.jsonSerialize(), null, options ? 2 : void 0);
+	}
+	toPrettyJson() {
+		return JSON.stringify(this.jsonSerialize(), null, 2);
+	}
+	/**
+	* String representation.
+	*/
+	toString() {
+		return this.toJson();
+	}
+};
+
+//#endregion
+//#region src/Validator.ts
+(0, simple_body_validator.register)("telephone", function(value) {
+	return /^\d{3}-\d{3}-\d{4}$/.test(value);
+});
+var Validator = class Validator {
+	#messages;
+	#after = [];
+	data;
+	rules;
+	_errors;
+	passing = false;
+	executed = false;
+	instance;
+	errorBagName = "default";
+	registeredCustomRules = [new ExtendedRules()];
+	shouldStopOnFirstFailure = false;
+	constructor(data, rules, messages = {}) {
+		this.data = data;
+		this.rules = rules;
+		this.#messages = messages;
+		this._errors = new MessageBag();
+		this.bindServices();
+	}
+	/**
+	* Validate the data and return the instance
+	*/
+	static make(data, rules, messages = {}) {
+		return new Validator(data, rules, messages);
+	}
+	/**
+	* Run the validator and store results.
+	*/
+	async passes() {
+		if (this.executed) return this._errors.isEmpty();
+		const exec = await this.execute();
+		for (const after of this.#after) after();
+		return exec.passing;
+	}
+	/**
+	* Opposite of passes()
+	*/
+	async fails() {
+		return !await this.passes();
+	}
+	/**
+	* Throw if validation fails, else return executed data
+	* 
+	* @throws ValidationException if validation fails
+	*/
+	async validate() {
+		if (!await this.passes()) throw new ValidationException(this, JSON.stringify(this._errors.toArray()));
+		return this.validatedData();
+	}
+	/**
+	* Run the validator's rules against its data.
+	* @param bagName 
+	* @returns 
+	*/
+	async validateWithBag(bagName) {
+		this.errorBagName = bagName;
+		return this.validate();
+	}
+	/**
+	* Stop validation on first failure.
+	*/
+	stopOnFirstFailure() {
+		this.shouldStopOnFirstFailure = true;
+		return this;
+	}
+	/**
+	* Get the data that passed validation.
+	*/
+	validatedData() {
+		const validKeys = Object.keys(this.rules);
+		const clean = {};
+		for (const key of validKeys) if (this.data[key] !== void 0) clean[key] = this.data[key];
+		return clean;
+	}
+	/**
+	* Return all validated input.
+	*/
+	validated() {
+		return Object.fromEntries(Object.entries(this.data).filter(([key]) => key in this.rules));
+	}
+	/**
+	* Return a portion of validated input
+	*/
+	safe() {
+		const validated = this.validated();
+		return {
+			only: (keys) => Object.fromEntries(Object.entries(validated).filter(([key]) => keys.includes(key))),
+			except: (keys) => Object.fromEntries(Object.entries(validated).filter(([key]) => !keys.includes(key)))
+		};
+	}
+	/**
+	* Get the message container for the validator.
+	*/
+	async messages() {
+		if (!this.#messages) await this.passes();
+		return this.#messages;
+	}
+	/**
+	* Add an after validation callback.
+	*
+	* @param  callback
+	*/
+	after(callback) {
+		if (Array.isArray(callback)) for (const rule of callback) this.#after.push(() => rule.toString().startsWith("class") ? new rule(this) : rule(this));
+		else if (typeof callback === "function") this.#after.push(() => callback(this));
+		return this;
+	}
+	/**
+	* Get all errors.
+	*/
+	errors() {
+		return this._errors;
+	}
+	errorBag() {
+		return this.errorBagName;
+	}
+	/**
+	* Reset validator with new data.
+	*/
+	setData(data) {
+		this.data = data;
+		this.executed = false;
+		return this;
+	}
+	/**
+	* Set validation rules.
+	*/
+	setRules(rules) {
+		this.rules = rules;
+		this.executed = false;
+		return this;
+	}
+	/**
+	* Add a single rule to existing rules.
+	*/
+	addRule(key, rule) {
+		this.rules[key] = rule;
+		return this;
+	}
+	/**
+	* Merge additional rules.
+	*/
+	mergeRules(rules) {
+		this.rules = {
+			...this.rules,
+			...rules
+		};
+		return this;
+	}
+	/**
+	* Get current data.
+	*/
+	getData() {
+		return this.data;
+	}
+	/**
+	* Get current rules.
+	*/
+	getRules() {
+		return this.rules;
+	}
+	/**
+	* Bind all required services here.
+	*/
+	bindServices() {
+		/**
+		* Register all custom rules
+		*/
+		for (const reged of this.registeredCustomRules) if (reged instanceof ValidationRule) {
+			if (reged.setData) reged.setData(this.data);
+			if (reged.setValidator) reged.setValidator(this);
+			for (const rule of reged.rules) {
+				(0, simple_body_validator.register)(rule.name, rule.validator);
+				if (rule.message) (0, simple_body_validator.setTranslationObject)({ en: { [rule.name]: rule.message } });
+			}
+		}
+		return this;
+	}
+	async execute() {
+		const instance = (0, simple_body_validator.make)().setData(this.data).setRules(this.rules).setCustomMessages(this.#messages).stopOnFirstFailure(this.shouldStopOnFirstFailure);
+		this.passing = await instance.validateAsync();
+		this.executed = true;
+		this.instance = instance;
+		if (!this.passing) this._errors = new MessageBag(instance.errors().all());
+		return this;
+	}
+};
+
+//#endregion
+//#region src/ValidationException.ts
+var ValidationException = class ValidationException extends __h3ravel_foundation.UnprocessableEntityHttpException {
+	validator;
+	response;
+	status = 422;
+	errorBag = "default";
+	redirectTo;
+	constructor(validator, response$1 = null, errorBag = "default") {
+		super(ValidationException.summarize(validator));
+		this.name = "ValidationException";
+		this.validator = validator;
+		this.response = response$1;
+		this.errorBag = errorBag;
+		Object.setPrototypeOf(this, ValidationException.prototype);
+	}
+	/**
+	* Send a custom response body for this exception
+	* 
+	* @param request 
+	* @returns 
+	*/
+	toResponse(request) {
+		if (!request.expectsJson()) {
+			session().flash("_errors", this.errors());
+			session().flash("_old", request.all());
+			return response().setCharset("utf-8").redirect(request.getHeader("referer") || "/", 302);
+		}
+		return {
+			message: this.message,
+			errors: this.errors()
+		};
+	}
+	/**
+	* Create a new validation exception from a plain array of messages.
+	*/
+	static withMessages(messages) {
+		const validator = new Validator({}, {});
+		const bag = new MessageBag();
+		for (const [key, value] of Object.entries(messages)) {
+			const list = Array.isArray(value) ? value : [value];
+			for (const message of list) bag.add(key, message);
+		}
+		validator._errors = bag;
+		return new ValidationException(validator);
+	}
+	/**
+	* Create a readable summary message from the validation errors.
+	*/
+	static summarize(validator) {
+		const messages = validator.errors().all();
+		if (!messages.length || typeof messages[0] !== "string") return "The given data was invalid.";
+		let message = messages.shift();
+		const count = messages.length;
+		if (count > 0) message += ` (and ${count} more ${__h3ravel_support.Str.plural("error", count)})`;
+		return message;
+	}
+	/**
+	* Get all of the validation error messages.
+	*/
+	errors() {
+		return this.validator.errors().getMessages();
+	}
+	/**
+	* Set the HTTP status code to be used for the response.
+	*/
+	setStatus(status) {
+		this.status = status;
+		return this;
+	}
+	/**
+	* Set the error bag on the exception.
+	*/
+	setErrorBag(errorBag) {
+		this.errorBag = errorBag;
+		return this;
+	}
+	/**
+	* Set the URL to redirect to on a validation error.
+	*/
+	setRedirectTo(url) {
+		this.redirectTo = url;
+		return this;
+	}
+	/**
+	* Get the underlying response instance.
+	*/
+	getResponse() {
+		return this.response;
+	}
+};
+
+//#endregion
+exports.ExtendedRules = ExtendedRules;
+exports.ImplicitRule = ImplicitRule;
+exports.MessageBag = MessageBag;
+exports.ValidationException = ValidationException;
+exports.ValidationRule = ValidationRule;
+exports.ValidationServiceProvider = ValidationServiceProvider;
+exports.Validator = Validator;