nox-validation 1.1.5 → 1.1.7

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/helpers.js

@@ -384,6 +384,22 @@ const generateField = (name, path, schema_definition_type, type, childrenFields
   };
 };
 
+const createChildrenFieldsFiles = (key) => {
+  const existingField = generateField(
+    "existing",
+    `${key}.existing`,
+    constants.types.OBJECT_ID,
+    constants.types.ARRAY
+  );
+  const deleteField = generateField(
+    "delete",
+    `${key}.delete`,
+    constants.types.OBJECT_ID,
+    constants.types.ARRAY
+  );
+  return [existingField, deleteField];
+}
+
 const generateRelationalFieldV1 = (key = "", collectionFields = [], relationType) => {
   if (relationType === constants.interfaces.MANY_TO_ANY) {
     return [
@@ -707,6 +723,11 @@ const buildNestedStructure = ({
   schemaFields.forEach((item) => {
     const pathParts = item.path.split(".");
     const key = pathParts.join(".");
+    const isV2File = apiVersion === constants.API_VERSION.V2 && [
+      constants.interfaces.FILES,
+      constants.interfaces.FILE,
+      constants.interfaces.FILE_IMAGE,
+    ].includes(item?.meta?.interface);
 
     const currentDepth = currentDepthMap.get(isRoot ? item.path : rootPath) || 0;
 
@@ -714,9 +735,7 @@ const buildNestedStructure = ({
 
     let childFields;
 
-    const definedType = generateType(item, apiVersion);
-    // apiVersion === constants.API_VERSION.V1 ? convertTypesV1(item) : convertTypes(item);
-    // const isUserKey = default_fields.some((field) => item?.path?.includes(field));
+    let definedType = generateType(item, apiVersion);
 
     if (definedType.find_relations && currentDepth <= maxLevel) {
       const relationDetail = getForeignCollectionDetails({
@@ -757,6 +776,12 @@ const buildNestedStructure = ({
       }
     }
 
+    if(isV2File){
+      definedType.array_type = constants.types.OBJECT;
+      definedType.type = constants.types.OBJECT;
+      childFields = createChildrenFieldsFiles(key);
+    }
+
     const node = {
       field_id: item?._id,
       schema_id: item?.schema_id,
@@ -776,7 +801,7 @@ const buildNestedStructure = ({
       custom_error_message: item?.meta?.validations?.validation_msg,
       children:
         childFields?.length > 0
-          ? apiVersion === constants.API_VERSION.V1 &&
+          ? isV2File ? childFields:apiVersion === constants.API_VERSION.V1 &&
             item.meta?.interface !== constants.interfaces.TRANSLATIONS
             ? generateRelationalFieldV1(key, childFields, item.meta?.interface)
             : generateRelationalField(key, childFields, item.meta?.interface)

package/package.json

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