nox-validation 1.1.4 → 1.1.6

package/lib/constant.js

@@ -154,6 +154,10 @@ const API_VERSIONS = Object.freeze(Object.values(API_VERSION));
 const LANGUAGES = Object.freeze({
   en: "en",
   nl: "nl",
+  lv:"lv",
+  pl:"pl",
+  ro:"ro",
+  ru:"ru",
 });
 
 const LOCALE_NL_MESSAGES = Object.freeze({
@@ -244,9 +248,189 @@ const LOCALE_EN_MESSAGES = Object.freeze({
   SIZE: "{field} must have a size of {value}",
 });
 
+const LOCALE_LV_MESSAGES = Object.freeze({
+  INVALID_VALUE: `{field} satur nederīgu vērtību.`,
+  EMPTY: `{field} jābūt tukšam.`,
+  NOT_EMPTY: `{field} nedrīkst būt tukšs.`,
+  ONE_OF: `{field} jābūt vienai no šīm vērtībām: {value}.`,
+  NOT_ONE_OF: `{field} nedrīkst būt viena no šīm vērtībām: {value}.`,
+  REQUIRED: `{field} ir obligāts.`,
+  OPTIONAL: `{field} ir izvēles.`,
+  NOT_NULLABLE: `{field} nevar būt null.`,
+  INVALID_TYPE: `{field} satur nederīgu ievades tipu. Atļauts tikai {type}.`,
+  NOT_ALLOWED_FIELD: `{field} nav atļauts.`,
+  COMPARE: `{field} neatbilst paredzētajai vērtībai.`,
+  RULES_COMPARE: `{field} neatbilst salīdzināšanas noteikumiem.`,
+  ALLOW: `{field} satur tikai atļautās rakstzīmes.`,
+  NOT_ALLOWED: `{field} satur neatļautas rakstzīmes.`,
+  REGEX_MATCH: `{field} formāts nav derīgs.`,
+  REGEX_START_WITH: `{field} jāsākas ar {value}.`,
+  REGEX_ENDS_WITH: `{field} jābeidzas ar {value}.`,
+  REGEX_CONTAINS: `{field} jāietver {value}.`,
+  REGEX_EXACT: `{field} jābūt tieši {value}.`,
+  REGEX_NOT_START_WITH: `{field} nedrīkst sākties ar {value}.`,
+  REGEX_NOT_ENDS_WITH: `{field} nedrīkst beigties ar {value}.`,
+  REGEX_NOT_CONTAINS: `{field} nedrīkst saturēt {value}.`,
+  MIN_STRING: `{field} jābūt vismaz {min} rakstzīmes garam.`,
+  MAX_STRING: `{field} jābūt ne vairāk kā {max} rakstzīmes garam.`,
+  MIN_NUMBER: `{field} jābūt vismaz {min}.`,
+  MAX_NUMBER: `{field} jābūt ne vairāk kā {max}.`,
+  AND: `{field} jābūt vienai no {value}`,
+  OR: `{field} jābūt vienai no {value}`,
+  EQUAL: `{field} jābūt vienādam ar {value}`,
+  NOT_EQUAL: `{field} nedrīkst būt vienāds ar {value}`,
+  LESS_THAN: `{field} jābūt mazākam par {value}`,
+  LESS_THAN_EQUAL: `{field} jābūt mazākam vai vienādam ar {value}`,
+  GREATER_THAN: `{field} jābūt lielākam par {value}`,
+  GREATER_THAN_EQUAL: `{field} jābūt lielākam vai vienādam ar {value}`,
+  IN: `{field} jābūt vienai no šīm vērtībām: {value}`,
+  NOT_IN: `{field} nedrīkst saturēt kādu no šīm vērtībām: {value}`,
+  EXISTS: `{field} ir jāeksistē`,
+  TYPE: `{field} jābūt {value} tipam`,
+  MOD: `{field} jābūt atlikumam {value[1]} dalot ar {value[0]}`,
+  ALL: `{field} jāietver visas šīs vērtības: {value}`,
+  SIZE: `{field} izmēram jābūt {value}`,
+});
+
+const LOCALE_PL_MESSAGES = Object.freeze({
+  INVALID_VALUE: `{field} zawiera nieprawidłową wartość.`,
+  EMPTY: `{field} powinno być puste.`,
+  NOT_EMPTY: `{field} nie powinno być puste.`,
+  ONE_OF: `{field} powinno być jedną z następujących wartości: {value}.`,
+  NOT_ONE_OF: `{field} nie powinno być jedną z następujących wartości: {value}.`,
+  REQUIRED: `{field} jest wymagane.`,
+  OPTIONAL: `{field} jest opcjonalne.`,
+  NOT_NULLABLE: `{field} nie może być puste (null).`,
+  INVALID_TYPE: `{field} zawiera nieprawidłowy typ. Dozwolony tylko {type}.`,
+  NOT_ALLOWED_FIELD: `{field} nie jest dozwolone.`,
+  COMPARE: `{field} nie pasuje do oczekiwanej wartości.`,
+  RULES_COMPARE: `{field} nie spełnia reguł porównania.`,
+  ALLOW: `{field} zawiera tylko dozwolone znaki.`,
+  NOT_ALLOWED: `{field} zawiera niedozwolone znaki.`,
+  REGEX_MATCH: `Format pola {field} jest nieprawidłowy.`,
+  REGEX_START_WITH: `{field} powinno zaczynać się od {value}.`,
+  REGEX_ENDS_WITH: `{field} powinno kończyć się na {value}.`,
+  REGEX_CONTAINS: `{field} powinno zawierać {value}.`,
+  REGEX_EXACT: `{field} powinno być dokładnie równe {value}.`,
+  REGEX_NOT_START_WITH: `{field} nie powinno zaczynać się od {value}.`,
+  REGEX_NOT_ENDS_WITH: `{field} nie powinno kończyć się na {value}.`,
+  REGEX_NOT_CONTAINS: `{field} nie powinno zawierać {value}.`,
+  MIN_STRING: `{field} musi mieć co najmniej {min} znaków.`,
+  MAX_STRING: `{field} może mieć maksymalnie {max} znaków.`,
+  MIN_NUMBER: `{field} musi być co najmniej {min}.`,
+  MAX_NUMBER: `{field} może być maksymalnie {max}.`,
+  AND: `{field} musi być jedną z wartości: {value}`,
+  OR: `{field} musi być jedną z wartości: {value}`,
+  EQUAL: `{field} musi być równe {value}`,
+  NOT_EQUAL: `{field} nie może być równe {value}`,
+  LESS_THAN: `{field} musi być mniejsze niż {value}`,
+  LESS_THAN_EQUAL: `{field} musi być mniejsze lub równe {value}`,
+  GREATER_THAN: `{field} musi być większe niż {value}`,
+  GREATER_THAN_EQUAL: `{field} musi być większe lub równe {value}`,
+  IN: `{field} musi być jedną z następujących wartości: {value}`,
+  NOT_IN: `{field} nie może zawierać żadnej z następujących wartości: {value}`,
+  EXISTS: `{field} musi istnieć`,
+  TYPE: `{field} musi być typu {value}`,
+  MOD: `{field} musi mieć resztę {value[1]} po podzieleniu przez {value[0]}`,
+  ALL: `{field} musi zawierać wszystkie z następujących wartości: {value}`,
+  SIZE: `{field} musi mieć rozmiar {value}`,
+});
+
+const LOCALE_RO_MESSAGES = Object.freeze({
+  INVALID_VALUE: `{field} conține o valoare invalidă.`,
+  EMPTY: `{field} trebuie să fie gol.`,
+  NOT_EMPTY: `{field} nu trebuie să fie gol.`,
+  ONE_OF: `{field} trebuie să fie una dintre următoarele: {value}.`,
+  NOT_ONE_OF: `{field} nu trebuie să fie una dintre următoarele: {value}.`,
+  REQUIRED: `{field} este obligatoriu.`,
+  OPTIONAL: `{field} este opțional.`,
+  NOT_NULLABLE: `{field} nu poate fi nul.`,
+  INVALID_TYPE: `{field} conține un tip de intrare invalid. Doar {type} este permis.`,
+  NOT_ALLOWED_FIELD: `{field} nu este permis.`,
+  COMPARE: `{field} nu se potrivește cu valoarea așteptată.`,
+  RULES_COMPARE: `{field} nu respectă regulile de comparare.`,
+  ALLOW: `{field} conține doar caractere permise.`,
+  NOT_ALLOWED: `{field} conține caractere nepermise.`,
+  REGEX_MATCH: `Formatul lui {field} este invalid.`,
+  REGEX_START_WITH: `{field} trebuie să înceapă cu {value}.`,
+  REGEX_ENDS_WITH: `{field} trebuie să se termine cu {value}.`,
+  REGEX_CONTAINS: `{field} trebuie să conțină {value}.`,
+  REGEX_EXACT: `{field} trebuie să fie exact {value}.`,
+  REGEX_NOT_START_WITH: `{field} nu trebuie să înceapă cu {value}.`,
+  REGEX_NOT_ENDS_WITH: `{field} nu trebuie să se termine cu {value}.`,
+  REGEX_NOT_CONTAINS: `{field} nu trebuie să conțină {value}.`,
+  MIN_STRING: `{field} trebuie să aibă cel puțin {min} caractere.`,
+  MAX_STRING: `{field} trebuie să aibă cel mult {max} caractere.`,
+  MIN_NUMBER: `{field} trebuie să fie cel puțin {min}.`,
+  MAX_NUMBER: `{field} trebuie să fie cel mult {max}.`,
+  AND: `{field} trebuie să fie una dintre: {value}`,
+  OR: `{field} trebuie să fie una dintre: {value}`,
+  EQUAL: `{field} trebuie să fie egal cu {value}`,
+  NOT_EQUAL: `{field} nu trebuie să fie egal cu {value}`,
+  LESS_THAN: `{field} trebuie să fie mai mic decât {value}`,
+  LESS_THAN_EQUAL: `{field} trebuie să fie mai mic sau egal cu {value}`,
+  GREATER_THAN: `{field} trebuie să fie mai mare decât {value}`,
+  GREATER_THAN_EQUAL: `{field} trebuie să fie mai mare sau egal cu {value}`,
+  IN: `{field} trebuie să fie una dintre următoarele valori: {value}`,
+  NOT_IN: `{field} nu trebuie să conțină niciuna dintre următoarele valori: {value}`,
+  EXISTS: `{field} trebuie să existe`,
+  TYPE: `{field} trebuie să fie de tipul {value}`,
+  MOD: `{field} trebuie să aibă restul {value[1]} când este împărțit la {value[0]}`,
+  ALL: `{field} trebuie să conțină toate valorile: {value}`,
+  SIZE: `{field} trebuie să aibă dimensiunea {value}`,
+});
+
+const LOCALE_RU_MESSAGES = Object.freeze({
+  INVALID_VALUE: `{field} содержит недопустимое значение.`,
+  EMPTY: `{field} должно быть пустым.`,
+  NOT_EMPTY: `{field} не должно быть пустым.`,
+  ONE_OF: `{field} должно быть одним из следующих значений: {value}.`,
+  NOT_ONE_OF: `{field} не должно быть одним из следующих значений: {value}.`,
+  REQUIRED: `{field} обязательно для заполнения.`,
+  OPTIONAL: `{field} является необязательным.`,
+  NOT_NULLABLE: `{field} не может быть null.`,
+  INVALID_TYPE: `{field} содержит недопустимый тип. Допустим только {type}.`,
+  NOT_ALLOWED_FIELD: `{field} не разрешено.`,
+  COMPARE: `{field} не соответствует ожидаемому значению.`,
+  RULES_COMPARE: `{field} не соответствует правилам сравнения.`,
+  ALLOW: `{field} содержит только допустимые символы.`,
+  NOT_ALLOWED: `{field} содержит недопустимые символы.`,
+  REGEX_MATCH: `Неверный формат для {field}.`,
+  REGEX_START_WITH: `{field} должно начинаться с {value}.`,
+  REGEX_ENDS_WITH: `{field} должно заканчиваться на {value}.`,
+  REGEX_CONTAINS: `{field} должно содержать {value}.`,
+  REGEX_EXACT: `{field} должно быть точно равно {value}.`,
+  REGEX_NOT_START_WITH: `{field} не должно начинаться с {value}.`,
+  REGEX_NOT_ENDS_WITH: `{field} не должно заканчиваться на {value}.`,
+  REGEX_NOT_CONTAINS: `{field} не должно содержать {value}.`,
+  MIN_STRING: `{field} должно содержать минимум {min} символов.`,
+  MAX_STRING: `{field} должно содержать не более {max} символов.`,
+  MIN_NUMBER: `{field} должно быть не меньше {min}.`,
+  MAX_NUMBER: `{field} должно быть не больше {max}.`,
+  AND: `{field} должно быть одним из: {value}`,
+  OR: `{field} должно быть одним из: {value}`,
+  EQUAL: `{field} должно быть равно {value}`,
+  NOT_EQUAL: `{field} не должно быть равно {value}`,
+  LESS_THAN: `{field} должно быть меньше {value}`,
+  LESS_THAN_EQUAL: `{field} должно быть меньше или равно {value}`,
+  GREATER_THAN: `{field} должно быть больше {value}`,
+  GREATER_THAN_EQUAL: `{field} должно быть больше или равно {value}`,
+  IN: `{field} должно быть одним из следующих значений: {value}`,
+  NOT_IN: `{field} не должно содержать ни одно из значений: {value}`,
+  EXISTS: `{field} должно существовать`,
+  TYPE: `{field} должно быть типа {value}`,
+  MOD: `{field} должно иметь остаток {value[1]} при делении на {value[0]}`,
+  ALL: `{field} должно содержать все следующие значения: {value}`,
+  SIZE: `{field} должно иметь размер {value}`,
+});
+
 const LOCALE_MESSAGES = Object.freeze({
   [LANGUAGES.en]:LOCALE_EN_MESSAGES,
-  [LANGUAGES.nl]:LOCALE_NL_MESSAGES
+  [LANGUAGES.nl]:LOCALE_NL_MESSAGES,
+  [LANGUAGES.lv]:LOCALE_LV_MESSAGES,
+  [LANGUAGES.pl]:LOCALE_PL_MESSAGES,
+  [LANGUAGES.ro]:LOCALE_RO_MESSAGES,
+  [LANGUAGES.ru]:LOCALE_RU_MESSAGES
 })
 
 module.exports = {

package/lib/validate.js

@@ -725,7 +725,7 @@ const validate = (data) => {
     onlyFormFields,
   } = data;
 
-  const error_messages = constants.LOCALE_MESSAGES[language];
+  const error_messages = constants.LOCALE_MESSAGES[language] ?? constants.LOCALE_MESSAGES[constants.LANGUAGES.en];
 
   let result = { status: true, errors: {}, data: formData };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nox-validation",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "validate dynamic schema",
   "main": "index.js",
   "scripts": {