@solidstarters/solid-core 1.2.143 → 1.2.145

package/src/services/authentication.service.ts

@@ -15,7 +15,7 @@ import { JwtService } from '@nestjs/jwt';
 import { InjectRepository } from '@nestjs/typeorm';
 import { isEmpty, isNotEmpty } from 'class-validator';
 import { randomInt, randomUUID } from 'crypto';
-import { SMTPEMailService } from 'src/services/mail/SMTPEmailService';
+import { SMTPEMailService } from 'src/services/mail/smtp-email.service';
 import { Msg91OTPService } from 'src/services/sms/Msg91OTPService';
 import { Repository } from 'typeorm';
 import { iamConfig, jwtConfig } from '../config/iam.config';
@@ -46,6 +46,8 @@ import { RoleMetadataService } from './role-metadata.service';
 import commonConfig from 'src/config/common.config';
 import { UserActivityHistoryService } from './user-activity-history.service';
 import { RequestContextService } from './request-context.service';
+import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { SUCCESS_MESSAGES } from 'src/constants/success-messages';
 
 
 enum LoginProvider {
@@ -111,17 +113,17 @@ export class AuthenticationService {
         const user = await this.resolveUser(signInDto.username, signInDto.email);
 
         if (!user) {
-            throw new UnauthorizedException('User does not exists');
+            throw new UnauthorizedException(ERROR_MESSAGES.USER_NOT_FOUND);
         }
         if (!user.active) {
-            throw new UnauthorizedException('User profile not activated');
+            throw new UnauthorizedException(ERROR_MESSAGES.USER_NOT_ACTIVE);
         }
         const isEqual = await this.hashingService.compare(
             signInDto.password,
             user.password,
         );
         if (!isEqual) {
-            throw new UnauthorizedException('Password does not match');
+            throw new UnauthorizedException(ERROR_MESSAGES.PASSWORD_INCORRECT);
         }
 
         return user;
@@ -130,7 +132,7 @@ export class AuthenticationService {
     async signUp(signUpDto: SignUpDto, activeUser: ActiveUserData = null): Promise<User> {
         // If public registrations are disabled and no activeUser is present when invoking signUp then we throw an exception.
         if (!(await this.settingService.getConfigValue('allowPublicRegistration')) && !activeUser) {
-            throw new BadRequestException('Public registrations are disabled.');
+            throw new BadRequestException(ERROR_MESSAGES.PUBLIC_REGISTRATION_DISABLED);
         }
 
         try {
@@ -150,7 +152,7 @@ export class AuthenticationService {
         } catch (err) {
             const pgUniqueViolationErrorCode = '23505';
             if (err.code === pgUniqueViolationErrorCode) {
-                throw new ConflictException();
+                throw new ConflictException(ERROR_MESSAGES.USER_ALREADY_EXISTS);
             }
             throw err;
         }
@@ -172,7 +174,7 @@ export class AuthenticationService {
         catch (err) {
             const pgUniqueViolationErrorCode = '23505';
             if (err.code === pgUniqueViolationErrorCode) {
-                throw new ConflictException(parseUniqueConstraintError(err.detail || 'A unique constraint violation occurred.'));
+                throw new ConflictException(parseUniqueConstraintError(err.detail || ERROR_MESSAGES.UNIQUE_CONSTRAINT_VIOLATION));
             }
             throw err;
         }
@@ -275,17 +277,17 @@ export class AuthenticationService {
     async otpInitiateRegistration(signUpDto: OTPSignUpDto) {
         try {
             if (!this.isPasswordlessRegistrationEnabled()) {
-                throw new BadRequestException('Passwordless registration is not enabled');
+                throw new BadRequestException(ERROR_MESSAGES.PASSWORDLESS_REGISTRATION_DISABLED);
             }
             // Validate if either mobile or email is present.
             if (isEmpty(signUpDto.mobile) && isEmpty(signUpDto.email)) {
-                throw new BadRequestException('Either mobile or email is required for initiating registration');
+                throw new BadRequestException(ERROR_MESSAGES.REGISTRATION_REQUIRES_CONTACT);
             }
             if (signUpDto.validationSources.includes(TransactionalRegistrationValidationSource.EMAIL) && isEmpty(signUpDto.email)) {
-                throw new BadRequestException('Email is required for email validation source');
+                throw new BadRequestException(ERROR_MESSAGES.EMAIL_REQUIRED_FOR_VALIDATION);
             }
             if (signUpDto.validationSources.includes(TransactionalRegistrationValidationSource.MOBILE) && isEmpty(signUpDto.mobile)) {
-                throw new BadRequestException('Mobile is required for mobile validation source');
+                throw new BadRequestException(ERROR_MESSAGES.MOBILE_REQUIRED_FOR_VALIDATION);
             }
 
             // Validate if user already exists.
@@ -297,7 +299,7 @@ export class AuthenticationService {
                 ]
             });
             if (isNotEmpty(existingUser) && existingUser.active) {
-                throw new ConflictException('User already exists. Please sign in');
+                throw new ConflictException(ERROR_MESSAGES.USER_ALREADY_EXISTS);
             }
             const finalRegistrationVerificationSources = this.calculateVerificationSources(this.iamConfiguration.passwordlessRegistrationValidateWhat, signUpDto);
             let user = existingUser
@@ -314,11 +316,11 @@ export class AuthenticationService {
 
             // Send OTP to the user through email or SMS, depending on the configuration.
             this.notifyUserOnOtpInitiateRegistration(user, finalRegistrationVerificationSources);
-            return { message: 'User registration initiated. OTP sent to the user.' }
+            return { message: SUCCESS_MESSAGES.OTP_SENT_SUCCESS_REGISTRATION }
         } catch (err) {
             const pgUniqueViolationErrorCode = '23505';
             if (err.code === pgUniqueViolationErrorCode) {
-                throw new ConflictException();
+                throw new ConflictException(ERROR_MESSAGES.USER_ALREADY_EXISTS);
             }
             throw err;
         }
@@ -346,7 +348,7 @@ export class AuthenticationService {
     // Generate the validation tokens for the user i.e (system configured + user provided)
     private populateVerificationTokens(finalRegistrationValidationSources: string[], user: User) {
         if (finalRegistrationValidationSources.length === 0) {
-            throw new BadRequestException('At least one validation source is required');
+            throw new BadRequestException(ERROR_MESSAGES.VALIDATION_SOURCE_REQUIRED);
         }
         if (finalRegistrationValidationSources.includes(TransactionalRegistrationValidationSource.EMAIL)) {
             const { token, expiresAt } = this.otp();
@@ -407,7 +409,7 @@ export class AuthenticationService {
 
     async otpConfirmRegistration(confirmSignUpDto: OTPConfirmOTPDto) {
         if (!this.isPasswordlessRegistrationEnabled()) {
-            throw new BadRequestException('Passwordless registration is not enabled');
+            throw new BadRequestException(ERROR_MESSAGES.PASSWORDLESS_REGISTRATION_DISABLED);
         }
 
         // Based on the identifier, validate by query the user table.
@@ -418,13 +420,13 @@ export class AuthenticationService {
                 }
             });
             if (!user) {
-                throw new UnauthorizedException('User does not exist');
+                throw new UnauthorizedException(ERROR_MESSAGES.USER_NOT_FOUND);
             }
             if (user.emailVerificationTokenOnRegistration !== confirmSignUpDto.otp) {
-                throw new UnauthorizedException('Invalid OTP');
+                throw new UnauthorizedException(ERROR_MESSAGES.INVALID_OTP);
             }
             if (user.emailVerificationTokenOnRegistrationExpiresAt < new Date()) {
-                throw new UnauthorizedException('OTP expired');
+                throw new UnauthorizedException(ERROR_MESSAGES.OTP_EXPIRED);
             }
             user.emailVerifiedOnRegistrationAt = new Date();
             user.emailVerificationTokenOnRegistration = null;
@@ -440,13 +442,13 @@ export class AuthenticationService {
                 }
             });
             if (!user) {
-                throw new UnauthorizedException('User does not exist');
+                throw new UnauthorizedException(ERROR_MESSAGES.USER_NOT_FOUND);
             }
             if (user.mobileVerificationTokenOnRegistration !== confirmSignUpDto.otp) {
-                throw new UnauthorizedException('Invalid OTP');
+                throw new UnauthorizedException(ERROR_MESSAGES.INVALID_OTP);
             }
             if (user.mobileVerificationTokenOnRegistrationExpiresAt < new Date()) {
-                throw new UnauthorizedException('Invalid OTP');
+                throw new UnauthorizedException(ERROR_MESSAGES.INVALID_OTP);
             }
             user.mobileVerifiedOnRegistrationAt = new Date();
             user.mobileVerificationTokenOnRegistration = null;
@@ -456,7 +458,7 @@ export class AuthenticationService {
             this.triggerRegistrationEvent(savedUser);
             return { active: savedUser.active, message: `User registration verified for ${confirmSignUpDto.type}` }
         }
-        throw new BadRequestException('Invalid type. Must be either email or mobile');
+        throw new BadRequestException(ERROR_MESSAGES.INVALID_VERIFICATION_TYPE);
     }
 
     private triggerRegistrationEvent(savedUser: User) {
@@ -512,7 +514,7 @@ export class AuthenticationService {
 
     async otpInitiateLogin(signInDto: OTPSignInDto) {
         if (!this.isPasswordlessRegistrationEnabled()) {
-            throw new BadRequestException('Passwordless registration is not enabled');
+            throw new BadRequestException(ERROR_MESSAGES.PASSWORDLESS_REGISTRATION_DISABLED);
         }
 
         // Validate & generate otp token for the user based on the identifier type.
@@ -523,10 +525,10 @@ export class AuthenticationService {
                 }
             });
             if (!user) {
-                throw new UnauthorizedException('User does not exist');
+                throw new UnauthorizedException(ERROR_MESSAGES.USER_NOT_FOUND);
             }
             if (!user.active) {
-                throw new UnauthorizedException('User is inactive');
+                throw new UnauthorizedException(ERROR_MESSAGES.USER_INACTIVE);
             }
             const { token, expiresAt } = this.otp();
             user.emailVerificationTokenOnLogin = token;
@@ -540,7 +542,7 @@ export class AuthenticationService {
                 }
             });
             if (!user) {
-                throw new UnauthorizedException('User does not exist');
+                throw new UnauthorizedException(ERROR_MESSAGES.USER_NOT_FOUND);
             }
 
             const { token, expiresAt } = this.otp();
@@ -550,9 +552,9 @@ export class AuthenticationService {
             this.notifyUserOnOtpInititateLogin(user, RegistrationValidationSource.MOBILE);
         }
         else {
-            throw new BadRequestException('Invalid type. Must be either email or mobile');
+            throw new BadRequestException(ERROR_MESSAGES.INVALID_VERIFICATION_TYPE);
         }
-        return { message: 'User login initiated. OTP sent to the user.' };
+        return { message: SUCCESS_MESSAGES.OTP_SENT_SUCCESS_LOGIN };
     }
 
     private async notifyUserOnOtpInititateLogin(user: User, loginType: RegistrationValidationSource) {
@@ -595,7 +597,7 @@ export class AuthenticationService {
 
     async otpConfirmLogin(confirmSignInDto: OTPConfirmOTPDto) {
         if (!this.isPasswordlessRegistrationEnabled()) {
-            throw new BadRequestException('Passwordless registration is not enabled');
+            throw new BadRequestException(ERROR_MESSAGES.PASSWORDLESS_REGISTRATION_DISABLED);
         }
         if (confirmSignInDto.type === RegistrationValidationSource.EMAIL) {
             const user = await this.userRepository.findOne({
@@ -605,16 +607,16 @@ export class AuthenticationService {
                 relations: ['roles']
             });
             if (!user) {
-                throw new UnauthorizedException('User does not exist');
+                throw new UnauthorizedException(ERROR_MESSAGES.USER_NOT_FOUND);
             }
             if (!user.active) {
-                throw new UnauthorizedException('User is inactive');
+                throw new UnauthorizedException(ERROR_MESSAGES.USER_INACTIVE);
             }
             if (user.emailVerificationTokenOnLogin !== confirmSignInDto.otp) {
-                throw new UnauthorizedException('Invalid OTP');
+                throw new UnauthorizedException(ERROR_MESSAGES.INVALID_OTP);
             }
             if (user.emailVerificationTokenOnLoginExpiresAt < new Date()) {
-                throw new UnauthorizedException('Invalid OTP');
+                throw new UnauthorizedException(ERROR_MESSAGES.INVALID_OTP);
             }
             user.emailVerifiedOnLoginAt = new Date();
             user.emailVerificationTokenOnLogin = null;
@@ -632,16 +634,16 @@ export class AuthenticationService {
                 relations: ['roles']
             });
             if (!user) {
-                throw new UnauthorizedException('User does not exist');
+                throw new UnauthorizedException(ERROR_MESSAGES.USER_NOT_ACTIVE);
             }
             if (!user.active) {
-                throw new UnauthorizedException('User is inactive');
+                throw new UnauthorizedException(ERROR_MESSAGES.USER_INACTIVE);
             }
             if (user.mobileVerificationTokenOnLogin !== confirmSignInDto.otp) {
-                throw new UnauthorizedException('Invalid OTP');
+                throw new UnauthorizedException(ERROR_MESSAGES.INVALID_OTP);
             }
             if (user.mobileVerificationTokenOnLoginExpiresAt < new Date()) {
-                throw new UnauthorizedException('Invalid OTP');
+                throw new UnauthorizedException(ERROR_MESSAGES.INVALID_OTP);
             }
             user.mobileVerifiedOnLoginAt = new Date();
             user.mobileVerificationTokenOnLogin = null;
@@ -653,7 +655,7 @@ export class AuthenticationService {
             return { accessToken, refreshToken, user: { id, username, email, mobile, lastLoginProvider, roles } };
 
         }
-        throw new BadRequestException('Invalid type. Must be either email or mobile');
+        throw new BadRequestException(ERROR_MESSAGES.INVALID_VERIFICATION_TYPE);
     }
 
     async changePassword(changePasswordDto: ChangePasswordDto, activeUser: ActiveUserData) {
@@ -661,26 +663,26 @@ export class AuthenticationService {
             where: { id: changePasswordDto.id }
         });
         if (!user) {
-            throw new NotFoundException('User does not exists');
+            throw new NotFoundException(ERROR_MESSAGES.USER_NOT_FOUND);
         }
 
         if (!user.active) {
-            throw new UnauthorizedException('User is inactive');
+            throw new UnauthorizedException(ERROR_MESSAGES.USER_INACTIVE);
         }
 
         // 2. Validate if user has used a provider which is "local", only then it makes sense for us to initiate the forgot password routine.
         if (user.lastLoginProvider !== 'local') {
-            throw new BadRequestException('User seems to have used a passwordless mode to authenticate.');
+            throw new BadRequestException(ERROR_MESSAGES.NON_LOCAL_PROVIDER);
         }
 
         // Check if ID's match
         if (!(user.id === activeUser.sub)) {
-            throw new BadRequestException("User ID's do not match ");
+            throw new BadRequestException(ERROR_MESSAGES.USER_ID_MISMATCH);
         }
 
         // Check if username's match
         if (!(user.username === activeUser.username)) {
-            throw new BadRequestException("User username's do not match");
+            throw new BadRequestException(ERROR_MESSAGES.USERNAME_MISMATCH);
         }
 
         // Check if old password is matching.
@@ -689,7 +691,7 @@ export class AuthenticationService {
             user.password,
         );
         if (!isEqual) {
-            throw new UnauthorizedException('Incorrect current password specified...');
+            throw new UnauthorizedException(ERROR_MESSAGES.INCORRECT_CURRENT_PASSWORD);
         }
 
         // Update Password
@@ -700,7 +702,7 @@ export class AuthenticationService {
         user.forcePasswordChange = false;
 
         if (await this.isPasswordDuplicate(user)) {
-            throw new BadRequestException('Previously used passwords cannot be used again.');
+            throw new BadRequestException(ERROR_MESSAGES.PASSWORD_REUSED);
         }
         await this.deleteOldPasswords(user);
 
@@ -724,15 +726,15 @@ export class AuthenticationService {
         const user = await this.resolveUser(initiateForgotPasswordDto.username, initiateForgotPasswordDto.email);
 
         if (!user) {
-            throw new NotFoundException('User does not exists');
+            throw new NotFoundException(ERROR_MESSAGES.USER_NOT_FOUND);
         }
         if (!user.active) {
-            throw new UnauthorizedException('User is inactive');
+            throw new UnauthorizedException(ERROR_MESSAGES.USER_INACTIVE);
         }
 
         // 2. Validate if user has used a provider which is "local", only then it makes sense for us to initiate the forgot password routine. 
         if (user.lastLoginProvider !== 'local') {
-            throw new BadRequestException('User seems to have used a passwordless mode to authenticate.');
+            throw new BadRequestException(ERROR_MESSAGES.NON_LOCAL_PROVIDER);
         }
 
         // 3. Generate a 6 digit validation token, we send this token to the user over their email & mobile number (controlled using configuration).
@@ -746,7 +748,7 @@ export class AuthenticationService {
         // 5. Return. 
         return {
             status: 'success',
-            message: 'Forgot password - token generated and sent',
+            message: SUCCESS_MESSAGES.FORGOT_PASSWORD_TOKEN_SENT,
             error: '',
             errorCode: '',
             data: {
@@ -807,23 +809,23 @@ export class AuthenticationService {
         const user = await this.resolveUser(confirmForgotPasswordDto.username, confirmForgotPasswordDto.email);
 
         if (!user) {
-            throw new NotFoundException('User does not exists');
+            throw new NotFoundException(ERROR_MESSAGES.USER_NOT_FOUND);
         }
 
         // 2. Validate if user has used a provider which is "local", only then it makes sense for us to initiate the forgot password routine. 
         if (user.lastLoginProvider !== 'local') {
-            throw new BadRequestException('User seems to have used a passwordless mode to authenticate.');
+            throw new BadRequestException(ERROR_MESSAGES.NON_LOCAL_PROVIDER);
         }
         if (!user.active) {
-            throw new UnauthorizedException('User is inactive');
+            throw new UnauthorizedException(ERROR_MESSAGES.USER_INACTIVE);
         }
 
         // 3. Validate the verification token is proper & update the user record. 
         if (user.verificationTokenOnForgotPassword !== confirmForgotPasswordDto.verificationToken) {
-            throw new UnauthorizedException('Invalid verification token');
+            throw new UnauthorizedException(ERROR_MESSAGES.INVALID_VERIFICATION_TOKEN);
         }
         if (user.verificationTokenOnForgotPasswordExpiresAt < new Date()) {
-            throw new UnauthorizedException('Invalid verification token');
+            throw new UnauthorizedException(ERROR_MESSAGES.INVALID_VERIFICATION_TOKEN);
         }
         user.forgotPasswordConfirmedAt = new Date();
         user.verificationTokenOnForgotPassword = null;
@@ -834,7 +836,7 @@ export class AuthenticationService {
         user.password = confirmForgotPasswordDto.password
 
         if (await this.isPasswordDuplicate(user)) {
-            throw new BadRequestException('Previously used passwords cannot be used again.');
+            throw new BadRequestException(ERROR_MESSAGES.PASSWORD_REUSED);
         }
         await this.deleteOldPasswords(user);
 
@@ -849,7 +851,7 @@ export class AuthenticationService {
 
         return {
             status: 'success',
-            message: 'Forgot password confirmed',
+            message: SUCCESS_MESSAGES.FORGOT_PASSWORD_CONFIRMED,
             error: '',
             errorCode: '',
             data: {}
@@ -950,7 +952,7 @@ export class AuthenticationService {
                 }
             });
             if (!user) {
-                throw new UnauthorizedException();
+                throw new UnauthorizedException(ERROR_MESSAGES.SESSION_INVALID);
             }
 
             // TODO: Replace the if else condition below with a call to validateAndRotate - Done
@@ -973,10 +975,10 @@ export class AuthenticationService {
         } catch (err) {
             if (err instanceof InvalidatedRefreshTokenError) {
                 // Take action: notify user that his refresh token might have been stolen?
-                throw new UnauthorizedException('Access denied');
+                throw new UnauthorizedException(ERROR_MESSAGES.ACCESS_DENIED);
             }
 
-            throw new UnauthorizedException();
+            throw new UnauthorizedException(ERROR_MESSAGES.SESSION_EXPIRED);
         }
     }
 
@@ -1007,10 +1009,10 @@ export class AuthenticationService {
                 // TODO: remove the access code both from the database.
                 return userProfile;
             } else {
-                throw new UnauthorizedException('Invalid user profile');
+                throw new UnauthorizedException(ERROR_MESSAGES.INVALID_USER_PROFILE);
             }
         } catch (error) {
-            throw new UnauthorizedException('Failed to fetch user profile from Google OAuth service');
+            throw new UnauthorizedException(ERROR_MESSAGES.GOOGLE_OAUTH_PROFILE_FETCH_FAILED);
         }
     }
 
@@ -1071,11 +1073,11 @@ export class AuthenticationService {
             await this.userActivityHistoryService.logEvent('logout', user);
 
 
-            return { message: 'Logged out successfully' };
+            return { message: SUCCESS_MESSAGES.LOGOUT_SUCCESS};
         } catch (err) {
             throw err instanceof UnauthorizedException || err instanceof InternalServerErrorException
                 ? err
-                : new InternalServerErrorException('Logout failed due to an unexpected error.');
+                : new InternalServerErrorException(ERROR_MESSAGES.LOGOUT_FAILED);
         }
     }
 
@@ -1083,7 +1085,7 @@ export class AuthenticationService {
     async activateUser(userId: number) {
         const user = await this.userService.findOne(userId, {});
         if (!user) {
-            throw new NotFoundException('User not found');
+            throw new NotFoundException(ERROR_MESSAGES.USER_NOT_FOUND);
         }
         user.active = true;
         await this.userRepository.save(user);

package/src/services/crud-helper.service.ts

@@ -4,6 +4,7 @@ import { classify } from "@angular-devkit/core/src/utils/strings";
 import { ActiveUserData } from "src/interfaces/active-user-data.interface";
 import { SolidRegistry } from "src/helpers/solid-registry";
 import { Logger } from "@nestjs/common";
+import { ERROR_MESSAGES } from "src/constants/error-messages";
 
 
 export class CrudHelperService {
@@ -174,7 +175,7 @@ export class CrudHelperService {
         const normalizedSort = this.normalize(sort);
         const normalizedGroupBy = this.normalize(groupBy);
         if (normalizedGroupBy.length > 1) {
-            throw new Error('buildFilterQuery: Only 1 Group by field is supported currently');
+            throw new Error(ERROR_MESSAGES.GROUP_BY_LIMIT);
         }
 
         // Depending upon the populate option, apply the join clause
@@ -367,7 +368,7 @@ export class CrudHelperService {
         const groupByField = filteredDto.groupBy;
 
         if (!groupByField || (Array.isArray(groupByField) && groupByField.length !== 1)) {
-            throw new Error('Exactly one groupBy field is required to count grouped records.');
+            throw new Error(ERROR_MESSAGES.INVALID_GROUP_BY_COUNT);
         }
 
          const field = Array.isArray(groupByField) ? groupByField[0] : groupByField;

package/src/services/crud.service.ts

@@ -35,6 +35,8 @@ import { getMediaStorageProvider } from "./mediaStorageProviders";
 import { ModelMetadataService } from "./model-metadata.service";
 import { ModuleMetadataService } from "./module-metadata.service";
 import { isArray } from "class-validator";
+import { ERROR_MESSAGES } from "src/constants/error-messages";
+import { SUCCESS_MESSAGES } from "src/constants/success-messages";
 
 export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDto, so we get the proper types in our service
 
@@ -66,7 +68,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         if (solidRequestContext.activeUser) {
             const hasPermission = this.crudHelperService.hasCreatePermissionOnModel(solidRequestContext.activeUser, model.singularName);
             if (!hasPermission) {
-                throw new BadRequestException('Forbidden');
+                throw new BadRequestException(ERROR_MESSAGES.FORBIDDEN);
             }
         }
         // const inverseRelationFields = await this.loadInverseRelationFields();
@@ -92,7 +94,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             return savedEntity;
         } catch (error) {
             if (error instanceof QueryFailedError && error.message.includes('duplicate key value violates unique constraint')) {
-                throw new BadRequestException('Duplicate entry. A record with similar unique fields already exists.');
+                throw new BadRequestException(ERROR_MESSAGES.DUPLICATE_ENTRY);
             }
             throw error;
         }
@@ -153,7 +155,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
     //TODO: Will the updates be partial i.e PATCH or full i.e PUT
     async update(id: number, updateDto: any, files: Express.Multer.File[] = [], isPartialUpdate: boolean = false, solidRequestContext: any = {}, isUpdate: boolean = false): Promise<T> {
         if (!id) {
-            throw new Error('Id is required for update');
+            throw new Error(ERROR_MESSAGES.ID_REQUIRED_FOR_UPDATE);
         }
         isUpdate = true;
         const model = await this.loadModel();
@@ -161,7 +163,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         if (solidRequestContext.activeUser) {
             const hasPermission = this.crudHelperService.hasUpdatePermissionOnModel(solidRequestContext.activeUser, model.singularName);
             if (!hasPermission) {
-                throw new BadRequestException('Forbidden');
+                throw new BadRequestException(ERROR_MESSAGES.FORBIDDEN);
             }
         }
         const entity = await this.repo.findOne({
@@ -207,14 +209,14 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
     //TODO: Will the updates be partial i.e PATCH or full i.e PUT
     async delete(id: number, solidRequestContext: any = {}) {
         if (!id) {
-            throw new Error('Id is required for update');
+            throw new Error(ERROR_MESSAGES.ID_REQUIRED_FOR_DELETE);
         }
         const loadedmodel = await this.loadModel();
         // Check wheather user has update permission for model
         if (solidRequestContext.activeUser) {
             const hasPermission = this.crudHelperService.hasDeletePermissionOnModel(solidRequestContext.activeUser, loadedmodel.singularName);
             if (!hasPermission) {
-                throw new BadRequestException('Forbidden');
+                throw new BadRequestException(ERROR_MESSAGES.FORBIDDEN);
             }
         }
 
@@ -373,7 +375,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
                         return new ManyToManyRelationFieldCrudManager(inverseManyToManyOptions);
                     }
                 }
-                else throw new Error('Relation type not supported in crud service');
+                else throw new Error(ERROR_MESSAGES.RELATION_TYPE_NOT_SUPPORTED);
                 // return (fieldMetadata.relationType === 'many-to-one') ? new ManyToOneRelationFieldCrudManager(fieldMetadata, entityManager) : new ManyToManyRelationFieldCrudManager(fieldMetadata, entityManager); //FIXME many-to-many pending
                 //    ManyToOne -> fieldId. The value is saved as is. No transformation is required
                 //    OneToMany -> fieldIds. Get the value of the oneToMany field side.  No transformation is required (While saving special provision to be made)
@@ -624,7 +626,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         if (solidRequestContext.activeUser) {
             const hasPermission = this.crudHelperService.hasReadPermissionOnModel(solidRequestContext.activeUser, model.singularName);
             if (!hasPermission) {
-                throw new BadRequestException('Forbidden');
+                throw new BadRequestException(ERROR_MESSAGES.FORBIDDEN);
             }
         }
 
@@ -659,7 +661,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         if (solidRequestContext.activeUser) {
             const hasPermission = this.crudHelperService.hasCreatePermissionOnModel(solidRequestContext.activeUser, loadedmodel.singularName);
             if (!hasPermission) {
-                throw new BadRequestException('Forbidden');
+                throw new BadRequestException(ERROR_MESSAGES.FORBIDDEN);
             }
         }
 
@@ -709,7 +711,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
     async deleteMany(ids: number[], solidRequestContext: any = {}): Promise<any> {
 
         if (!ids || ids.length === 0) {
-            throw new Error('At least one ID is required for deletion');
+            throw new Error(ERROR_MESSAGES.DELETE_IDS_REQUIRED);
         }
 
         const loadedmodel = await this.loadModel();
@@ -717,7 +719,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         if (solidRequestContext.activeUser) {
             const hasPermission = this.crudHelperService.hasDeletePermissionOnModel(solidRequestContext.activeUser, loadedmodel.singularName);
             if (!hasPermission) {
-                throw new BadRequestException('Forbidden');
+                throw new BadRequestException(ERROR_MESSAGES.FORBIDDEN);
             }
         }
         const model = await this.modelMetadataService.findOneBySingularName(this.modelName, {
@@ -757,7 +759,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             if (solidRequestContext.activeUser) {
                 const hasPermission = this.crudHelperService.hasRecoverPermissionOnModel(solidRequestContext.activeUser, loadedmodel.singularName);
                 if (!hasPermission) {
-                    throw new BadRequestException('Forbidden');
+                    throw new BadRequestException(ERROR_MESSAGES.FORBIDDEN);
                 }
             }
 
@@ -770,7 +772,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             });
 
             if (!softDeletedRows) {
-                throw new Error('No soft-deleted record found with the given ID.');
+                throw new Error(ERROR_MESSAGES.NO_SOFT_DELETED_RECORD_FOUND);
             }
 
             await this.repo.update(id, {
@@ -778,11 +780,11 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
                 deletedAt: null, deletedTracker: "not-deleted"
             });
 
-            return { message: 'Record successfully recovered', data: softDeletedRows };
+            return { message: SUCCESS_MESSAGES.RECORD_RECOVERED, data: softDeletedRows };
         } catch (error) {
             if (error instanceof QueryFailedError) {
                 if ((error as any).code === '23505') {
-                    throw new Error('Another record is conflicting with the record you are attempting to Un-Archive, either delete or change the other record so as to avoid this conflict.');
+                    throw new Error(ERROR_MESSAGES.CONFLICTING_RECORD_ON_UNARCHIVE);
                 }
             }
 
@@ -797,12 +799,12 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             if (solidRequestContext.activeUser) {
                 const hasPermission = this.crudHelperService.hasRecoverPermissionOnModel(solidRequestContext.activeUser, loadedmodel.singularName);
                 if (!hasPermission) {
-                    throw new BadRequestException('Forbidden');
+                    throw new BadRequestException(ERROR_MESSAGES.FORBIDDEN);
                 }
             }
 
             if (!ids || ids.length === 0) {
-                throw new Error("No IDs provided for recovery.");
+                throw new Error(ERROR_MESSAGES.DELETE_IDS_REQUIRED);
             }
 
             // Find soft-deleted records matching the given IDs
@@ -816,7 +818,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             });
 
             if (softDeletedRows.length === 0) {
-                throw new Error("No matching soft-deleted records found.");
+                throw new Error(ERROR_MESSAGES.NO_SOFT_DELETED_RECORDS_FOUND);
             }
 
             // Recover the specific records by setting deletedAt to null
@@ -826,13 +828,11 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
                 { deletedAt: null, deletedTracker: "not-deleted" }
             );
 
-            return { message: "Selected records successfully recovered", recoveredIds: ids };
+            return { message: SUCCESS_MESSAGES.SELECTED_RECORDS_RECOVERED, recoveredIds: ids };
         } catch (error) {
             if (error instanceof QueryFailedError) {
                 if ((error as any).code === "23505") {
-                    throw new Error(
-                        "Another record is conflicting with the record you are attempting to Un-Archive, either delete or change the other record to avoid this conflict."
-                    );
+                    throw new Error(ERROR_MESSAGES.CONFLICTING_RECORD_ON_UNARCHIVE);
                 }
             }
 
@@ -843,7 +843,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
 
     async getFieldMetadataRecursively(pathParts: string[], fields: FieldMetadata[]) {
         if (!pathParts || pathParts.length === 0) {
-            throw new BadRequestException('Path parts cannot be empty');
+            throw new BadRequestException(ERROR_MESSAGES.EMPTY_PATH_PARTS);
         }
 
         const [currentPart, ...remainingParts] = pathParts;