implerhq · chavda-bhavik · Sep 25, 2024 · Sep 25, 2024
diff --git a/apps/api/src/app/column/commands/add-column.command.ts b/apps/api/src/app/column/commands/add-column.command.ts
@@ -1,8 +1,8 @@
-import { ValidatorTypesEnum } from '@impler/client';
+import { ValidationTypesEnum } from '@impler/client';
 import { ColumnDelimiterEnum, ColumnTypesEnum } from '@impler/shared';
 
-export class ValidatorCommand {
-  validate: ValidatorTypesEnum;
+export class ValidationCommand {
+  validate: ValidationTypesEnum;
   min?: number;
   max?: number;
   uniqueKey?: string;
@@ -44,5 +44,5 @@ export class AddColumnCommand {
 
   delimiter?: ColumnDelimiterEnum;
 
-  validators?: ValidatorCommand[];
+  validations?: ValidationCommand[];
 }
diff --git a/apps/api/src/app/column/dtos/column-request.dto.ts b/apps/api/src/app/column/dtos/column-request.dto.ts
@@ -13,21 +13,21 @@ import {
 } from 'class-validator';
 import { Type } from 'class-transformer';
 
-import { ValidatorTypesEnum } from '@impler/client';
+import { ValidationTypesEnum } from '@impler/client';
 import { IsValidRegex } from '@shared/framework/is-valid-regex.validator';
 import { IsGreaterThan } from '@shared/framework/is-greator-than.validator';
 import { IsNumberOrString } from '@shared/framework/number-or-string.validator';
 import { ColumnDelimiterEnum, ColumnTypesEnum, Defaults } from '@impler/shared';
 
-export class ValidatorDto {
+export class ValidationDto {
   @ApiProperty({
     description: 'Specifies the type of column',
-    enum: ValidatorTypesEnum,
+    enum: ValidationTypesEnum,
   })
-  @IsEnum(ValidatorTypesEnum, {
-    message: `type must be one of ${Object.values(ValidatorTypesEnum).join(', ')}`,
+  @IsEnum(ValidationTypesEnum, {
+    message: `type must be one of ${Object.values(ValidationTypesEnum).join(', ')}`,
   })
-  validate: ValidatorTypesEnum;
+  validate: ValidationTypesEnum;
 
   @ApiPropertyOptional({
     description: 'Message to be shown on error',
@@ -57,7 +57,7 @@ export class ValidatorDto {
     description: 'Unique key of the validator',
   })
   @IsString()
-  @ValidateIf((object) => object.validate === ValidatorTypesEnum.UNIQUE_WITH)
+  @ValidateIf((object) => object.validate === ValidationTypesEnum.UNIQUE_WITH)
   uniqueKey: string;
 }
 
@@ -183,11 +183,11 @@ export class ColumnRequestDto {
   delimiter?: ColumnDelimiterEnum;
 
   @ApiPropertyOptional({
-    description: 'Validators for column',
+    description: 'Validations for column',
   })
   @IsArray()
   @IsOptional()
-  @Type(() => ValidatorDto)
+  @Type(() => ValidationDto)
   @ValidateNested({ each: true })
-  validators?: ValidatorDto[];
+  validations?: ValidationDto[];
 }
diff --git a/apps/api/src/app/common/dtos/Schema.dto.ts b/apps/api/src/app/common/dtos/Schema.dto.ts
@@ -15,7 +15,7 @@ import {
 import { Type } from 'class-transformer';
 import { ColumnTypesEnum, Defaults } from '@impler/shared';
 import { IsValidRegex } from '@shared/framework/is-valid-regex.validator';
-import { ValidatorDto } from 'app/column/dtos/column-request.dto';
+import { ValidationDto } from 'app/column/dtos/column-request.dto';
 
 export class SchemaDto {
   @ApiProperty({
@@ -111,11 +111,11 @@ export class SchemaDto {
   sequence: number;
 
   @ApiPropertyOptional({
-    description: 'Validators for column',
+    description: 'Validations for column',
   })
   @IsArray()
   @IsOptional()
-  @Type(() => ValidatorDto)
+  @Type(() => ValidationDto)
   @ValidateNested({ each: true })
-  validators?: ValidatorDto[];
+  validations?: ValidationDto[];
 }
diff --git a/apps/api/src/app/common/usecases/valid-request/valid-request.usecase.ts b/apps/api/src/app/common/usecases/valid-request/valid-request.usecase.ts
@@ -79,11 +79,11 @@ export class ValidRequest {
         }
 
         const hasImageColumns = parsedSchema.some((column) => column.type === ColumnTypesEnum.IMAGE);
-        const hasValidators = parsedSchema.some(
-          (column) => Array.isArray(column.validators) && column.validators.length > 0
+        const hasValidations = parsedSchema.some(
+          (column) => Array.isArray(column.validations) && column.validations.length > 0
         );
         let email: string;
-        if (hasImageColumns || hasValidators) {
+        if (hasImageColumns || hasValidations) {
           const project = await this.projectRepository.getUserOfProject(command.projectId);
           email = (project._userId as unknown as UserEntity).email;
         }
@@ -97,17 +97,17 @@ export class ValidRequest {
             throw new DocumentNotFoundException('Schema', command.schema, APIMessages.FEATURE_UNAVAILABLE.IMAGE_IMPORT);
           }
         }
-        if (hasValidators && email) {
-          const validatorsAvailable = await this.paymentAPIService.checkEvent({
+        if (hasValidations && email) {
+          const validationsAvailable = await this.paymentAPIService.checkEvent({
             email,
             billableMetricCode: AVAILABLE_BILLABLEMETRIC_CODE_ENUM.ADVANCED_VALIDATORS,
           });
 
-          if (!validatorsAvailable) {
+          if (!validationsAvailable) {
             throw new DocumentNotFoundException(
               'Schema',
               command.schema,
-              APIMessages.FEATURE_UNAVAILABLE.ADVANCED_VALIDATORS
+              APIMessages.FEATURE_UNAVAILABLE.ADVANCED_VALIDATIONS
             );
           }
         }

diff --git a/apps/api/src/app/review/usecases/do-review/base-review.usecase.ts b/apps/api/src/app/review/usecases/do-review/base-review.usecase.ts
@@ -7,10 +7,10 @@ import addKeywords from 'ajv-keywords';
 import * as customParseFormat from 'dayjs/plugin/customParseFormat';
 import Ajv, { AnySchemaObject, ErrorObject, ValidateFunction } from 'ajv';
 
-import { ValidatorErrorMessages } from '@shared/types/review.types';
+import { ValidationErrorMessages } from '@shared/types/review.types';
 import { ColumnTypesEnum, Defaults, ITemplateSchemaItem } from '@impler/shared';
 import { SManager, BATCH_LIMIT, MAIN_CODE, ExecuteIsolateResult } from '@shared/services/sandbox';
-import { ValidatorTypesEnum, LengthValidatorType, RangeValidatorType } from '@impler/client';
+import { ValidationTypesEnum, LengthValidationType, RangeValidationType } from '@impler/client';
 
 dayjs.extend(customParseFormat);
 
@@ -38,7 +38,7 @@ interface IRunData {
   numberColumnHeadings: Set<string>;
   dateFormats: Record<string, string[]>;
   uniqueCombinations: Record<string, string[]>;
-  validatorErrorMessages: ValidatorErrorMessages;
+  validationErrorMessages: ValidationErrorMessages;
   multiSelectColumnHeadings: Record<string, string>;
 }
 
@@ -105,19 +105,19 @@ export class BaseReview {
 
   private getProperty(column: ITemplateSchemaItem): Record<string, unknown> {
     let property: Record<string, unknown> = {};
-    const rangeValidator = column.validators?.find(
-      (validator) => validator.validate === ValidatorTypesEnum.RANGE
-    ) as RangeValidatorType;
-    const lengthValidator = column.validators?.find(
-      (validator) => validator.validate === ValidatorTypesEnum.LENGTH
-    ) as LengthValidatorType;
+    const rangeValidation = column.validations?.find(
+      (validation) => validation.validate === ValidationTypesEnum.RANGE
+    ) as RangeValidationType;
+    const lengthValidation = column.validations?.find(
+      (validation) => validation.validate === ValidationTypesEnum.LENGTH
+    ) as LengthValidationType;
 
     switch (column.type) {
       case ColumnTypesEnum.STRING:
         property = {
           type: 'string',
-          ...(typeof lengthValidator?.min === 'number' && { minLength: lengthValidator?.min }),
-          ...(typeof lengthValidator?.max === 'number' && { maxLength: lengthValidator?.max }),
+          ...(typeof lengthValidation?.min === 'number' && { minLength: lengthValidation?.min }),
+          ...(typeof lengthValidation?.max === 'number' && { maxLength: lengthValidation?.max }),
         };
         break;
       case ColumnTypesEnum.NUMBER:
@@ -126,8 +126,8 @@ export class BaseReview {
           ...(column.type === ColumnTypesEnum.NUMBER && { multipleOf: 1 }),
           type: ['number', 'null'],
           ...(!column.isRequired && { default: null }),
-          ...(typeof rangeValidator?.min === 'number' && { minimum: rangeValidator?.min }),
-          ...(typeof rangeValidator?.max === 'number' && { maximum: rangeValidator?.max }),
+          ...(typeof rangeValidation?.min === 'number' && { minimum: rangeValidation?.min }),
+          ...(typeof rangeValidation?.max === 'number' && { maximum: rangeValidation?.max }),
         };
         break;
       case ColumnTypesEnum.SELECT:
@@ -181,7 +181,7 @@ export class BaseReview {
   private getErrorsObject(
     errors: ErrorObject[],
     dateFormats: Record<string, string[]>,
-    validatorErrorMessages: ValidatorErrorMessages,
+    validationErrorMessages: ValidationErrorMessages,
     uniqueCombinations: Record<string, string[]>
   ): Record<string, string> {
     let field: string;
@@ -195,7 +195,7 @@ export class BaseReview {
             field: columnKey,
             dateFormats,
             uniqueCombinations,
-            validatorErrorMessages,
+            validationErrorMessages,
           });
         });
       } else {
@@ -209,7 +209,7 @@ export class BaseReview {
           field: field || error.schema[0],
           dateFormats,
           uniqueCombinations,
-          validatorErrorMessages,
+          validationErrorMessages,
         });
       }
 
@@ -223,39 +223,39 @@ export class BaseReview {
     error,
     field,
     uniqueCombinations,
-    validatorErrorMessages,
+    validationErrorMessages,
   }: {
     field: string;
     data: unknown;
     error: ErrorObject;
     dateFormats: Record<string, string[]>;
     uniqueCombinations: Record<string, string[]>;
-    validatorErrorMessages?: ValidatorErrorMessages;
+    validationErrorMessages?: ValidationErrorMessages;
   }): string {
     let message = '';
     switch (true) {
       // maximum length case
       case error.keyword === 'maxLength':
         message =
-          validatorErrorMessages?.[field]?.[ValidatorTypesEnum.LENGTH] ||
+          validationErrorMessages?.[field]?.[ValidationTypesEnum.LENGTH] ||
           `Length must be less than or equal to ${error.params.limit}`;
         break;
       // maximum length case
       case error.keyword === 'minLength':
         message =
-          validatorErrorMessages?.[field]?.[ValidatorTypesEnum.LENGTH] ||
+          validationErrorMessages?.[field]?.[ValidationTypesEnum.LENGTH] ||
           `Length must be greater than or equal to ${error.params.limit}`;
         break;
       // maximum number case
       case error.keyword === 'maximum':
         message =
-          validatorErrorMessages?.[field]?.[ValidatorTypesEnum.RANGE] ||
+          validationErrorMessages?.[field]?.[ValidationTypesEnum.RANGE] ||
           `${String(data)} must be less than or equal to ${error.params.limit}`;
         break;
       // minimum number case
       case error.keyword === 'minimum':
         message =
-          validatorErrorMessages?.[field]?.[ValidatorTypesEnum.RANGE] ||
+          validationErrorMessages?.[field]?.[ValidationTypesEnum.RANGE] ||
           `${String(data)} must be greater than or equal to ${error.params.limit}`;
         break;
       // empty string case
@@ -304,7 +304,7 @@ export class BaseReview {
         break;
       case !!uniqueCombinations[error.keyword]:
         message =
-          validatorErrorMessages?.[field]?.[ValidatorTypesEnum.UNIQUE_WITH] ||
+          validationErrorMessages?.[field]?.[ValidationTypesEnum.UNIQUE_WITH] ||
           `Value should be unique for combination of ${uniqueCombinations[error.keyword].toString()}`;
         break;
       default:
@@ -394,7 +394,7 @@ export class BaseReview {
     dataStream,
     uniqueCombinations,
     numberColumnHeadings,
-    validatorErrorMessages,
+    validationErrorMessages,
     multiSelectColumnHeadings,
   }: IRunData): Promise<ISaveResults> {
     return new Promise(async (resolve, reject) => {
@@ -420,7 +420,7 @@ export class BaseReview {
               validator,
               dateFormats,
               uniqueCombinations,
-              validatorErrorMessages,
+              validationErrorMessages,
             });
             if (validationResultItem.isValid) {
               validRecords++;
@@ -453,15 +453,15 @@ export class BaseReview {
     validator,
     dateFormats,
     uniqueCombinations,
-    validatorErrorMessages,
+    validationErrorMessages,
   }: {
     index: number;
     validator: ValidateFunction;
     passRecord: Record<string, any>;
     checkRecord: Record<string, any>;
     dateFormats: Record<string, string[]>;
     uniqueCombinations: Record<string, string[]>;
-    validatorErrorMessages?: Record<string, { string: Record<string, string> }>;
+    validationErrorMessages?: Record<string, { string: Record<string, string> }>;
   }) {
     const isValid = validator(checkRecord, {
       instancePath: `/${index}`,
@@ -471,7 +471,7 @@ export class BaseReview {
       dynamicAnchors: undefined,
     });
     if (!isValid) {
-      const errors = this.getErrorsObject(validator.errors, dateFormats, validatorErrorMessages, uniqueCombinations);
+      const errors = this.getErrorsObject(validator.errors, dateFormats, validationErrorMessages, uniqueCombinations);
 
       return {
         index,
@@ -578,7 +578,7 @@ export class BaseReview {
     dateFormats,
     uniqueCombinations,
     numberColumnHeadings,
-    validatorErrorMessages,
+    validationErrorMessages,
     multiSelectColumnHeadings,
   }: IRunData): Promise<IBatchItem[]> {
     return new Promise(async (resolve, reject) => {
@@ -606,7 +606,7 @@ export class BaseReview {
                 validator,
                 dateFormats,
                 uniqueCombinations,
-                validatorErrorMessages,
+                validationErrorMessages,
               });
               batchRecords.push(validationResultItem);
               if (batchRecords.length === BATCH_LIMIT) {