@diia-inhouse/validators 1.28.36 → 2.2.1

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { Rule, RuleValidator } from "./interfaces/rule.js";
+import { ParameterValidation } from "./interfaces/schema.js";
+import { ArrayRule, BooleanRule, CheckerFunctionError, CustomDateRule, DateRule, EmailRule, EnumRule, ListValidationSchema, NumberRule, ObjectIdRule, ObjectRule, RecordRule, RuleType, StringRule, ValidationRule, ValidationSchema, VersionRule } from "./interfaces/validationSchema.js";
+import { AppValidator } from "./validator.js";
+import { appVersionsValidationSchema, availableMobileCodes, emailRuValidation, emailValidation, getListValidationSchema, getStringDateSchema, listValidationSchema, phoneNumberValidation, phoneNumberWithoutPlusValidation, shortTextValidation, zipValidation } from "./schemas/index.js";
+export { AppValidator, ArrayRule, BooleanRule, CheckerFunctionError, CustomDateRule, DateRule, EmailRule, EnumRule, ListValidationSchema, NumberRule, ObjectIdRule, ObjectRule, ParameterValidation, RecordRule, Rule, RuleType, RuleValidator, StringRule, ValidationRule, ValidationSchema, VersionRule, appVersionsValidationSchema, availableMobileCodes, emailRuValidation, emailValidation, getListValidationSchema, getStringDateSchema, listValidationSchema, phoneNumberValidation, phoneNumberWithoutPlusValidation, shortTextValidation, zipValidation };

package/dist/index.js

@@ -1,20 +1,3 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./interfaces"), exports);
-__exportStar(require("./validator"), exports);
-__exportStar(require("./schemas"), exports);
-//# sourceMappingURL=index.js.map
+import { appVersionsValidationSchema, availableMobileCodes, emailRuValidation, emailValidation, getListValidationSchema, getStringDateSchema, listValidationSchema, phoneNumberValidation, phoneNumberWithoutPlusValidation, shortTextValidation, zipValidation } from "./schemas/index.js";
+import { AppValidator } from "./validator.js";
+export { AppValidator, appVersionsValidationSchema, availableMobileCodes, emailRuValidation, emailValidation, getListValidationSchema, getStringDateSchema, listValidationSchema, phoneNumberValidation, phoneNumberWithoutPlusValidation, shortTextValidation, zipValidation };

package/dist/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+import { Rule, RuleValidator } from "./rule.js";
+import { ParameterValidation } from "./schema.js";
+import { ArrayRule, BooleanRule, CheckerFunctionError, CustomDateRule, DateRule, EmailRule, EnumRule, ListValidationSchema, NumberRule, ObjectIdRule, ObjectRule, RecordRule, RuleType, StringRule, ValidationRule, ValidationSchema, VersionRule } from "./validationSchema.js";

package/dist/interfaces/rule.d.ts

@@ -0,0 +1,17 @@
+import FastestValidator, { MessagesType, ValidationSchema } from "fastest-validator";
+
+//#region src/interfaces/rule.d.ts
+type RuleValidator = (param: {
+  messages: MessagesType;
+  schema: ValidationSchema;
+}) => {
+  source: string;
+  sanitized?: boolean;
+};
+interface Rule {
+  getName(): string;
+  getMessage(): string;
+  getRule(validator: FastestValidator): RuleValidator;
+}
+//#endregion
+export { Rule, RuleValidator };

package/dist/interfaces/schema.d.ts

@@ -0,0 +1,8 @@
+//#region src/interfaces/schema.d.ts
+interface ParameterValidation {
+  regexp: string;
+  flags: string[];
+  errorMessage: string;
+}
+//#endregion
+export { ParameterValidation };

package/dist/interfaces/validationSchema.d.ts

@@ -0,0 +1,90 @@
+import { Context, ValidationRuleObject } from "fastest-validator";
+import { ObjectId } from "bson";
+
+//#region src/interfaces/validationSchema.d.ts
+type RuleType = "any" | "boolean" | "number" | "email" | "object" | "string" | "enum" | "uuid" | "array" | "forbidden" | "function" | "date" | "customDate" | "objectId" | "version" | "phoneNumber" | "internationalPhoneNumber" | "buffer" | "record";
+interface CheckerFunctionError {
+  type: string;
+  messages: string;
+  field?: string;
+}
+interface BasicRule<T extends RuleType> {
+  type: T;
+  optional?: boolean;
+  default?: unknown;
+  null?: boolean;
+}
+interface Sanitazible {
+  convert?: boolean;
+}
+interface NumberRule extends BasicRule<"number">, Sanitazible {
+  min?: number;
+  max?: number;
+  equal?: number;
+  notEqual?: number;
+  integer?: boolean;
+  positive?: boolean;
+  negative?: boolean;
+}
+interface ArrayRule<T = null> extends BasicRule<"array"> {
+  items?: ValidationProperty<T>;
+  empty?: boolean;
+  min?: number;
+  max?: number;
+  length?: number;
+  contains?: any;
+  enum?: any[];
+  unique?: boolean;
+}
+interface ObjectRule<T = null> extends BasicRule<"object"> {
+  props?: ValidationSchema$1<T>;
+  strict?: boolean;
+}
+interface RecordRule<K, V> extends BasicRule<"record"> {
+  key: EnumRule<K> | StringRule;
+  value: ValidationProperty<V> | ValidationProperty<V>[];
+}
+interface StringRule extends BasicRule<"string"> {
+  empty?: boolean;
+  min?: number;
+  max?: number;
+  length?: number;
+  pattern?: any;
+  contains?: any;
+  enum?: string[];
+  alpha?: boolean;
+  numeric?: boolean;
+  alphanum?: boolean;
+  alphadash?: boolean;
+  uppercase?: boolean;
+  custom?: (value: string, errors: CheckerFunctionError[], ruleSchema?: ValidationRuleObject, path?: string, parent?: object | null, context?: Context) => string;
+}
+interface EmailRule extends BasicRule<"email"> {
+  mode?: string;
+}
+interface VersionRule extends BasicRule<"version">, Sanitazible {
+  versions?: string[];
+}
+interface EnumRule<T = any> extends BasicRule<"enum"> {
+  values: T[];
+}
+interface DateRule extends BasicRule<"date">, Sanitazible {
+  format?: string;
+}
+interface ListValidationSchema {
+  skip: NumberRule;
+  limit: NumberRule;
+}
+interface CustomDateRule extends BasicRule<"customDate">, Sanitazible {}
+interface ObjectIdRule extends BasicRule<"objectId">, Sanitazible {}
+interface BooleanRule extends BasicRule<"boolean">, Sanitazible {}
+type CommonRule = BasicRule<"any" | "forbidden"> | EnumRule;
+type ComplexRule = StringRule | NumberRule | BooleanRule | ArrayRule | ObjectRule | DateRule | CustomDateRule | EmailRule | EnumRule | ObjectIdRule | RecordRule<string, unknown> | VersionRule;
+type ValidationProperty<T = null> = T extends null ? ValidationRule : T extends string ? StringRule | EmailRule | VersionRule | BasicRule<"uuid" | "phoneNumber" | "internationalPhoneNumber"> : T extends number ? NumberRule : T extends boolean ? BooleanRule : T extends Date ? DateRule | CustomDateRule | StringRule : T extends Buffer ? BasicRule<"buffer"> : T extends ObjectId ? ObjectIdRule | StringRule : T extends ArrayLike<infer U> ? ArrayRule<U> : T extends object ? ObjectRule<T> | RecordRule<keyof T, Required<T>[keyof T]> : ValidationRule;
+type Rule = string | boolean | ComplexRule | CommonRule | BasicRule<Exclude<RuleType, CommonRule["type"] | ComplexRule["type"]>>;
+type ValidationRule<T = null> = T extends null ? Rule : T extends object ? ObjectRule<T> : T extends ArrayLike<infer U> ? ArrayRule<U> : Rule;
+type ValidationSchema$1<T = null> = T extends null ? {
+  [path: string]: ValidationRule | ValidationRule[];
+} : { [path in keyof Required<T>]: ValidationProperty<T[path]> | ValidationProperty<T[path]>[] | CommonRule };
+//#endregion
+export { ArrayRule, BooleanRule, CheckerFunctionError, CustomDateRule, DateRule, EmailRule, EnumRule, ListValidationSchema, NumberRule, ObjectIdRule, ObjectRule, RecordRule, RuleType, StringRule, ValidationRule, ValidationSchema$1 as ValidationSchema, VersionRule };

package/dist/rules/buffer.js

@@ -1,31 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BufferValidationRule = void 0;
-class BufferValidationRule {
-    getName() {
-        return 'buffer';
-    }
-    getMessage() {
-        return "The '{field}' field must be an Buffer object!";
-    }
-    getRule(validator) {
-        /**
-         * Signature: function(value, field, parent, errors, context)
-         */
-        return ({ messages }) => {
-            const source = `
+//#region src/rules/buffer.ts
+var BufferValidationRule = class {
+	getName() {
+		return "buffer";
+	}
+	getMessage() {
+		return "The '{field}' field must be an Buffer object!";
+	}
+	getRule(validator) {
+		/**
+		* Signature: function(value, field, parent, errors, context)
+		*/
+		return ({ messages }) => {
+			return { source: `
                 if (!value || !(Buffer.isBuffer(value) || value.type === 'Buffer')) {
-                    ${validator.makeError({ type: 'buffer', actual: 'value', messages })}
+                    ${validator.makeError({
+				type: "buffer",
+				actual: "value",
+				messages
+			})}
                     return value;
                 }
 
                 return value;
-            `;
-            return {
-                source,
-            };
-        };
-    }
-}
-exports.BufferValidationRule = BufferValidationRule;
-//# sourceMappingURL=buffer.js.map
+            ` };
+		};
+	}
+};
+//#endregion
+export { BufferValidationRule };

package/dist/rules/date.js

@@ -1,50 +1,54 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DateValidationRule = void 0;
-class DateValidationRule {
-    checkPattern;
-    constructor(checkPattern = /(?:\d{2}\.){2}\d{4}/) {
-        this.checkPattern = checkPattern;
-    }
-    getName() {
-        return 'customDate';
-    }
-    getMessage() {
-        return "The '{field}' field must be a valid date string format (DD.MM.YYYY)!";
-    }
-    getRule(validator) {
-        /**
-         * Signature: function(value, field, parent, errors, context)
-         */
-        return ({ schema, messages }) => {
-            let sanitized = false;
-            const src = [
-                `
+//#region src/rules/date.ts
+var DateValidationRule = class {
+	checkPattern;
+	constructor(checkPattern = /(?:\d{2}\.){2}\d{4}/) {
+		this.checkPattern = checkPattern;
+	}
+	getName() {
+		return "customDate";
+	}
+	getMessage() {
+		return "The '{field}' field must be a valid date string format (DD.MM.YYYY)!";
+	}
+	getRule(validator) {
+		/**
+		* Signature: function(value, field, parent, errors, context)
+		*/
+		return ({ schema, messages }) => {
+			let sanitized = false;
+			const src = [`
                 if (typeof value !== 'string' || !${this.checkPattern.toString()}.test(value)) {
-                    ${validator.makeError({ type: 'customDate', actual: 'value', messages })}
+                    ${validator.makeError({
+				type: "customDate",
+				actual: "value",
+				messages
+			})}
                 }
-            `,
-            ];
-            if (schema.convert === true) {
-                sanitized = true;
-                src.push(`
+            `];
+			if (schema.convert === true) {
+				sanitized = true;
+				src.push(`
                     var origValue = value;
                     if (!(value instanceof Date)) {
                         var parts = origValue.split('.');
                         value = new Date(Date.UTC(parts[2], parts[1] - 1, parts[0]));
                         if (isNaN(value)) {
-                            ${validator.makeError({ type: 'customDate', actual: 'origValue', messages })}
+                            ${validator.makeError({
+					type: "customDate",
+					actual: "origValue",
+					messages
+				})}
                         }
                     }
                 `);
-            }
-            src.push('return value;');
-            return {
-                sanitized,
-                source: src.join('\n'),
-            };
-        };
-    }
-}
-exports.DateValidationRule = DateValidationRule;
-//# sourceMappingURL=date.js.map
+			}
+			src.push("return value;");
+			return {
+				sanitized,
+				source: src.join("\n")
+			};
+		};
+	}
+};
+//#endregion
+export { DateValidationRule };

package/dist/rules/index.js

@@ -1,23 +1,7 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./buffer"), exports);
-__exportStar(require("./date"), exports);
-__exportStar(require("./objectId"), exports);
-__exportStar(require("./phoneNumber"), exports);
-__exportStar(require("./version"), exports);
-__exportStar(require("./internationalPhoneNumber"), exports);
-//# sourceMappingURL=index.js.map
+import "./buffer.js";
+import "./date.js";
+import "./objectId.js";
+import "./phoneNumber.js";
+import "./version.js";
+import "./internationalPhoneNumber.js";
+export {};

package/dist/rules/internationalPhoneNumber.js

@@ -1,31 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InternationalPhoneNumberValidationRule = void 0;
-class InternationalPhoneNumberValidationRule {
-    checkPattern = /^\+?\d{1,4}?[\s.-]?\(?\d{1,3}?\)?(?:[\s.-]?\d{1,4}){2}[\s.-]?\d{1,9}$/g;
-    getName() {
-        return 'internationalPhoneNumber';
-    }
-    getMessage() {
-        return "The '{field}' field must be a string and valid international phone number!";
-    }
-    getRule(validator) {
-        /**
-         * Signature: function(value, field, parent, errors, context)
-         */
-        return ({ messages }) => {
-            const source = `
+//#region src/rules/internationalPhoneNumber.ts
+var InternationalPhoneNumberValidationRule = class {
+	checkPattern = /^\+?\d{1,4}?[\s.-]?\(?\d{1,3}?\)?(?:[\s.-]?\d{1,4}){2}[\s.-]?\d{1,9}$/g;
+	getName() {
+		return "internationalPhoneNumber";
+	}
+	getMessage() {
+		return "The '{field}' field must be a string and valid international phone number!";
+	}
+	getRule(validator) {
+		/**
+		* Signature: function(value, field, parent, errors, context)
+		*/
+		return ({ messages }) => {
+			return { source: `
                 if (typeof value !== 'string' || !${this.checkPattern.toString()}.test(value)) {
-                    ${validator.makeError({ type: 'internationalPhoneNumber', actual: 'value', messages })}
+                    ${validator.makeError({
+				type: "internationalPhoneNumber",
+				actual: "value",
+				messages
+			})}
                 }
 
                 return value;
-            `;
-            return {
-                source,
-            };
-        };
-    }
-}
-exports.InternationalPhoneNumberValidationRule = InternationalPhoneNumberValidationRule;
-//# sourceMappingURL=internationalPhoneNumber.js.map
+            ` };
+		};
+	}
+};
+//#endregion
+export { InternationalPhoneNumberValidationRule };

package/dist/rules/objectId.js

@@ -1,31 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectIdValidationRule = void 0;
+//#region src/rules/objectId.ts
 const PATTERN = /^[\da-f]{24}$/i;
-class ObjectIdValidationRule {
-    getName() {
-        return 'objectId';
-    }
-    getMessage() {
-        return "The '{field}' field must be an objectId string!";
-    }
-    getRule(validator) {
-        /**
-         * Signature: function(value, field, parent, errors, context)
-         */
-        return ({ messages }) => {
-            const source = `
+var ObjectIdValidationRule = class {
+	getName() {
+		return "objectId";
+	}
+	getMessage() {
+		return "The '{field}' field must be an objectId string!";
+	}
+	getRule(validator) {
+		/**
+		* Signature: function(value, field, parent, errors, context)
+		*/
+		return ({ messages }) => {
+			return { source: `
                 if (typeof value !== 'string' || !${PATTERN.toString()}.test(value)) {
-                    ${validator.makeError({ type: 'objectId', actual: 'value', messages })}
+                    ${validator.makeError({
+				type: "objectId",
+				actual: "value",
+				messages
+			})}
                 }
 
                 return value;
-            `;
-            return {
-                source,
-            };
-        };
-    }
-}
-exports.ObjectIdValidationRule = ObjectIdValidationRule;
-//# sourceMappingURL=objectId.js.map
+            ` };
+		};
+	}
+};
+//#endregion
+export { ObjectIdValidationRule };

package/dist/rules/phoneNumber.js

@@ -1,36 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PhoneNumberValidationRule = void 0;
-const schemas_1 = require("../schemas");
-class PhoneNumberValidationRule {
-    checkPattern;
-    constructor() {
-        // eslint-disable-next-line security/detect-non-literal-regexp
-        this.checkPattern = new RegExp(String.raw `^38(${schemas_1.availableMobileCodes.map((code) => `0${code}`).join('|')})\d{7}$`); // nosemgrep: eslint.detect-non-literal-regexp
-    }
-    getName() {
-        return 'phoneNumber';
-    }
-    getMessage() {
-        return "The '{field}' field must be a string and valid phone number. E.g. 380xxxxxxx!";
-    }
-    getRule(validator) {
-        /**
-         * Signature: function(value, field, parent, errors, context)
-         */
-        return ({ messages }) => {
-            const source = `
+import { availableMobileCodes } from "../schemas/index.js";
+//#region src/rules/phoneNumber.ts
+var PhoneNumberValidationRule = class {
+	checkPattern;
+	constructor() {
+		this.checkPattern = new RegExp(String.raw`^38(${availableMobileCodes.map((code) => `0${code}`).join("|")})\d{7}$`);
+	}
+	getName() {
+		return "phoneNumber";
+	}
+	getMessage() {
+		return "The '{field}' field must be a string and valid phone number. E.g. 380xxxxxxx!";
+	}
+	getRule(validator) {
+		/**
+		* Signature: function(value, field, parent, errors, context)
+		*/
+		return ({ messages }) => {
+			return { source: `
                 if (typeof value !== 'string' || !${this.checkPattern.toString()}.test(value)) {
-                    ${validator.makeError({ type: 'phoneNumber', actual: 'value', messages })}
+                    ${validator.makeError({
+				type: "phoneNumber",
+				actual: "value",
+				messages
+			})}
                 }
 
                 return value;
-            `;
-            return {
-                source,
-            };
-        };
-    }
-}
-exports.PhoneNumberValidationRule = PhoneNumberValidationRule;
-//# sourceMappingURL=phoneNumber.js.map
+            ` };
+		};
+	}
+};
+//#endregion
+export { PhoneNumberValidationRule };

package/dist/rules/version.js

@@ -1,51 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VersionValidationRule = void 0;
+//#region src/rules/version.ts
 const PATTERN = /^v\d+$/;
 /**
- * @deprecated
- */
-class VersionValidationRule {
-    getName() {
-        return 'version';
-    }
-    getMessage() {
-        return "The '{field}' field must be a valid version provided. E.g. v1";
-    }
-    getRule(validator) {
-        /**
-         * Signature: function(value, field, parent, errors, context)
-         */
-        return ({ schema, messages }) => {
-            const src = [
-                `
+* @deprecated
+*/
+var VersionValidationRule = class {
+	getName() {
+		return "version";
+	}
+	getMessage() {
+		return "The '{field}' field must be a valid version provided. E.g. v1";
+	}
+	getRule(validator) {
+		/**
+		* Signature: function(value, field, parent, errors, context)
+		*/
+		return ({ schema, messages }) => {
+			const src = [`
                 if (typeof value !== 'string') {
-                    ${validator.makeError({ type: 'string', actual: 'value', messages })}
+                    ${validator.makeError({
+				type: "string",
+				actual: "value",
+				messages
+			})}
                     return value;
                 }
-            `,
-            ];
-            if (Array.isArray(schema.versions) && schema.versions.length > 0) {
-                const { versions } = schema;
-                src.push(`
+            `];
+			if (Array.isArray(schema.versions) && schema.versions.length > 0) {
+				const { versions } = schema;
+				src.push(`
                     if (!${JSON.stringify(versions)}.includes(value)) {
-                        ${validator.makeError({ type: 'version', expected: `'${versions.join(', ')}'`, actual: 'value', messages })}
+                        ${validator.makeError({
+					type: "version",
+					expected: `'${versions.join(", ")}'`,
+					actual: "value",
+					messages
+				})}
                         return value;
                     }
                 `);
-            }
-            src.push(`
+			}
+			src.push(`
                 if (!${PATTERN.toString()}.test(value)) {
-                    ${validator.makeError({ type: 'version', actual: 'value', messages })}
+                    ${validator.makeError({
+				type: "version",
+				actual: "value",
+				messages
+			})}
                 }
 
                 return value;
             `);
-            return {
-                source: src.join('\n'),
-            };
-        };
-    }
-}
-exports.VersionValidationRule = VersionValidationRule;
-//# sourceMappingURL=version.js.map
+			return { source: src.join("\n") };
+		};
+	}
+};
+//#endregion
+export { VersionValidationRule };

package/dist/schemas/index.d.ts

@@ -0,0 +1,19 @@
+import { ParameterValidation } from "../interfaces/schema.js";
+import { ListValidationSchema, ObjectRule, StringRule } from "../interfaces/validationSchema.js";
+import { AppVersions } from "@diia-inhouse/types";
+
+//#region src/schemas/index.d.ts
+declare const availableMobileCodes: string[];
+declare const phoneNumberValidation: ParameterValidation;
+declare const phoneNumberWithoutPlusValidation: ParameterValidation;
+declare const emailValidation: ParameterValidation;
+declare const emailRuValidation: ParameterValidation;
+declare const shortTextValidation: ParameterValidation;
+declare const zipValidation: ParameterValidation;
+/** @deprecated use getListValidationSchema function instead */
+declare const listValidationSchema: ListValidationSchema;
+declare function getListValidationSchema(min?: number, max?: number): ListValidationSchema;
+declare const appVersionsValidationSchema: ObjectRule<AppVersions>;
+declare function getStringDateSchema(format?: string, optional?: boolean): StringRule;
+//#endregion
+export { appVersionsValidationSchema, availableMobileCodes, emailRuValidation, emailValidation, getListValidationSchema, getStringDateSchema, listValidationSchema, phoneNumberValidation, phoneNumberWithoutPlusValidation, shortTextValidation, zipValidation };