@solidstarters/solid-core 1.2.0

package/src/entities/user.entity.ts.bkp

@@ -0,0 +1,144 @@
+import { CommonEntity } from 'src/entities/common.entity';
+import { Column, Entity, JoinTable, ManyToMany } from 'typeorm';
+import { RoleMetadata } from './role-metadata.entity';
+
+@Entity("ss_iam_user")
+export class User extends CommonEntity {
+    @Column({ nullable: true })
+    fullName: string;
+
+    @Column({ unique: true })
+    username: string;
+
+    @Column({ unique: true, nullable: true })
+    email: string;
+
+    @Column({ unique: true, nullable: true })
+    mobile: string;
+
+    /**
+     * This was kept nullable for users created using provider of type Google etc.
+     */
+    @Column({ nullable: true })
+    password: string;
+
+    @Column({ default: false })
+    forcePasswordChange: boolean = false;
+
+    @Column({ name: 'last_login_provider', default: 'local' })
+    lastLoginProvider: string;
+
+    @Column({ name: "access_code", nullable: true })
+    accessCode: string;
+
+    @Column({ name: "google_access_token", nullable: true })
+    googleAccessToken: string;
+
+    @Column({ name: "google_id", nullable: true })
+    googleId: string;
+
+    @Column({ name: "google_profile_picture", nullable: true })
+    googleProfilePicture: string;
+
+    // @Column({ name: "otp", nullable: true })
+    // otpOnLogin: string;
+
+    // @Column({ name: "last_otp_created_at", nullable: true, type: 'timestamp' })
+    // lastOtpOnLoginCreatedAt: Date;
+
+    @Column({ default: false })
+    active: boolean;
+
+    // @Column('json', { nullable: true })
+    // @JoinTable(
+    //     {
+    //         name: 'ss_iam_user_role_metadata',
+    //         joinColumn: { name: 'user_id', referencedColumnName: 'id', foreignKeyConstraintName: 'fk_ss_user_role_user_id' },
+    //         inverseJoinColumn: { name: 'role_id', referencedColumnName: 'id', foreignKeyConstraintName: 'fk_ss_user_role_role_id' }
+    //     }
+    // )
+    // @ManyToMany(
+    //     type => RoleMetadata,
+    //     (role) => role.users,
+    //     {
+    //         cascade: true, // or optionally just insert or update ['insert']
+    //     }
+    // )
+    // roles: RoleMetadata[];
+    @ManyToMany(() => RoleMetadata, roleMetadata => roleMetadata.users, { cascade: true })
+    @JoinTable()
+    roles: RoleMetadata[];
+
+    // @JoinTable(
+    //     {
+    //         name: 'ss_user_permission',
+    //         joinColumn: { name: 'user_id', referencedColumnName: 'id', foreignKeyConstraintName: 'fk_ss_user_permission_role_id' },
+    //         inverseJoinColumn: { name: 'permission_id', referencedColumnName: 'id', foreignKeyConstraintName: 'fk_ss_user_permission_user_id' }
+    //     }
+    // )
+    // @ManyToMany(
+    //     type => Permission,
+    //     (permission) => permission.users,
+    //     {
+    //         cascade: true, // or optionally just insert or update ['insert']
+    //     }
+    // )
+    // permissions: Permission[];
+
+    // Forgot password fields
+    // Email
+    @Column({ name: "forgot_password_confirmed_at", nullable: true, type: 'timestamp' })
+    forgotPasswordConfirmedAt: Date;
+
+    @Column({ name: "verification_token_on_forgot_password", nullable: true })
+    verificationTokenOnForgotPassword: string;
+
+    @Column({ name: "verification_token_on_forgot_password_expires_at", nullable: true, type: 'timestamp' })
+    verificationTokenOnForgotPasswordExpiresAt: Date;
+
+    // Verification fields
+    // Registration
+    // Email
+    @Column({ name: "email_verified_on_registration_at", nullable: true, type: 'timestamp' })
+    emailVerifiedOnRegistrationAt: Date;
+
+    @Column({ name: "email_verification_token_on_registration", nullable: true })
+    emailVerificationTokenOnRegistration: string;
+
+    @Column({ name: "email_verification_token_on_registration_expires_at", nullable: true, type: 'timestamp' })
+    emailVerificationTokenOnRegistrationExpiresAt: Date;
+
+    // Mobile
+    @Column({ name: "mobile_verified_on_registration_at", nullable: true, type: 'timestamp' })
+    mobileVerifiedOnRegistrationAt: Date;
+
+    @Column({ name: "mobile_verification_token_on_registration", nullable: true })
+    mobileVerificationTokenOnRegistration: string;
+
+    @Column({ name: "mobile_verification_token_on_registration_expires_at", nullable: true, type: 'timestamp' })
+    mobileVerificationTokenOnRegistrationExpiresAt: Date;
+
+    // Login
+    // Email
+    @Column({ name: "email_verified_on_login_at", nullable: true, type: 'timestamp' })
+    emailVerifiedOnLoginAt: Date;
+
+    @Column({ name: "email_verification_token_on_login", nullable: true })
+    emailVerificationTokenOnLogin: string;
+
+    @Column({ name: "email_verification_token_on_login_expires_at", nullable: true, type: 'timestamp' })
+    emailVerificationTokenOnLoginExpiresAt: Date;
+
+    // Mobile
+    @Column({ name: "mobile_verified_on_login_at", nullable: true, type: 'timestamp' })
+    mobileVerifiedOnLoginAt: Date;
+
+    @Column({ name: "mobile_verification_token_on_login", nullable: true })
+    mobileVerificationTokenOnLogin: string;
+
+    @Column({ name: "mobile_verification_token_on_login_expires_at", nullable: true, type: 'timestamp' })
+    mobileVerificationTokenOnLoginExpiresAt: Date;
+
+    @Column({ type: 'jsonb', nullable: true })
+    customPayload: any;
+}

package/src/entities/view-metadata.entity.ts

@@ -0,0 +1,31 @@
+import { CommonEntity } from "src/entities/common.entity"
+import { Entity, Column, ManyToOne, Index, JoinColumn } from "typeorm";
+import { ModuleMetadata } from 'src/entities/module-metadata.entity';
+import { ModelMetadata } from 'src/entities/model-metadata.entity'
+@Entity("ss_view_metadata")
+export class ViewMetadata extends CommonEntity {
+    @Column({ name: "name", type: "varchar", unique: true })
+    name: string;
+
+    @Column({ name: "display_name", type: "varchar" })
+    displayName: string;
+
+    @Column({ name: "type", type: "varchar" })
+    type: string;
+
+    @Column({ name: "context", type: "text" })
+    context: any;
+
+    @Column({ name: "layout", type: "text" })
+    layout: any;
+
+    @Index()
+    @ManyToOne(() => ModuleMetadata, { onDelete: "CASCADE" })
+    @JoinColumn({ name: 'module_id', referencedColumnName: 'id' })
+    module: ModuleMetadata;
+
+    @Index()
+    @ManyToOne(() => ModelMetadata, { onDelete: "CASCADE" })
+    @JoinColumn({ name: 'model_id', referencedColumnName: 'id' })
+    model: ModelMetadata;
+}

package/src/enums/auth-type.enum.ts

@@ -0,0 +1,4 @@
+export enum AuthType {
+    Bearer,
+    None,
+}

package/src/filters/http-exception.filter.ts

@@ -0,0 +1,38 @@
+import { ExceptionFilter, Catch, ArgumentsHost, Logger } from '@nestjs/common';
+import { Response } from 'express';
+import { HttpStatusCodeMessages } from '../interceptors/logging.interceptor';
+
+@Catch()
+export class HttpExceptionFilter implements ExceptionFilter {
+    private readonly logger = new Logger(HttpExceptionFilter.name);
+
+    catch(exception: any, host: ArgumentsHost) {
+        const ctx = host.switchToHttp();
+        const response = ctx.getResponse<Response>();
+        const request = ctx.getRequest();
+        const status = exception.status || 500;
+        const message = exception.message || 'Internal server error';
+        const { method, url } = request;
+
+        // Log the error here
+        this.logger.error(`[${status || 500} ${HttpStatusCodeMessages[status] || 'Internal Server Error'}] ${method} ${url} - ${message}`);
+        this.logger.error(exception.stack || 'No stack trace available');
+
+        // Send the response to the client
+        if (exception.response) {
+            response.status(status).json({
+                ...exception.response,
+                error: message,
+                data: {}
+            });
+        }
+        else {
+            response.status(status).json({
+                statusCode: status,
+                message: [message],
+                error: message,
+                data: {}
+            });
+        }
+    }
+}

package/src/guards/access-token.guard.ts

@@ -0,0 +1,57 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  Inject,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { ConfigType } from '@nestjs/config';
+import { JwtService } from '@nestjs/jwt';
+import { Request } from 'express';
+import { ActiveUserData } from '../interfaces/active-user-data.interface';
+import { jwtConfig } from '../config/iam.config';
+import { REQUEST_USER_KEY } from "../constants";
+import { PermissionMetadataService } from '../services/permission-metadata.service';
+
+@Injectable()
+export class AccessTokenGuard implements CanActivate {
+  constructor(
+    private readonly jwtService: JwtService,
+    @Inject(jwtConfig.KEY)
+    private readonly jwtConfiguration: ConfigType<typeof jwtConfig>,
+    private readonly permissionsService: PermissionMetadataService,
+  ) { }
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    // 💡 NOTE: For GraphQL applications, you'd have to use the wrapper GqlExecutionContext here instead.
+    const request = context.switchToHttp().getRequest();
+    const token = this.extractTokenFromHeader(request);
+    if (!token) {
+      throw new UnauthorizedException();
+    }
+    try {
+      const payload: ActiveUserData = await this.jwtService.verifyAsync(
+        token,
+        this.jwtConfiguration,
+      );
+
+      // Load permissions given the user. 
+      const permissions = await this.permissionsService.findAllUsingRoles(payload.roles);
+      payload.permissions = permissions.map((permission) => permission.name);
+
+      request[REQUEST_USER_KEY] = payload;
+      // console.log(`About to set payload in the request user key:`);
+      // console.log(payload);
+    } catch {
+      throw new UnauthorizedException();
+    }
+    return true;
+  }
+
+  private extractTokenFromHeader(request: Request): string | undefined {
+    // Since token is included in the Authorization header something like 
+    // Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOjEsImVtYWlsIjoidXNlcjFAbmVzdGpzLmNvbSIsImlhdCI6MTcwMDk5NTk1MywiZXhwIjoxNzAwOTk5NTUzLCJhdWQiOiJsb2NhbGhvc3Q6MzAwMCIsImlzcyI6ImxvY2FsaG9zdDozMDAwIn0.303Y04SZjKqoPjJRq4hXHcarHeZYS878gPGWmw2SoUc
+    const [_, token] = request.headers.authorization?.split(' ') ?? [];
+    return token;
+  }
+}

package/src/guards/authentication.guard.ts

@@ -0,0 +1,70 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { AUTH_TYPE_KEY } from '../decorators/auth.decorator';
+import { AuthType } from '../enums/auth-type.enum';
+import { AccessTokenGuard } from './access-token.guard';
+import { IS_PUBLIC_KEY } from '../decorators/public.decorator';
+import { PermissionMetadataService } from '../services/permission-metadata.service';
+
+@Injectable()
+export class AuthenticationGuard implements CanActivate {
+  private static readonly defaultAuthType = AuthType.Bearer;
+  private readonly authTypeGuardMap: Record<
+    AuthType,
+    CanActivate | CanActivate[]> = {
+      [AuthType.Bearer]: this.accessTokenGuard,
+      [AuthType.None]: { canActivate: () => true },
+    };
+
+  constructor(
+    private readonly reflector: Reflector,
+    private readonly accessTokenGuard: AccessTokenGuard,
+    private readonly permissionService: PermissionMetadataService
+  ) { }
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    // If method marked as public, then we return with true, else go ahead and apply the access token guard. 
+    const contextLog = context.getHandler();
+    const request = context.switchToHttp().getRequest();
+    request['isListedInPublicRole'] = false;
+
+    const isPublic = this.reflector.get(IS_PUBLIC_KEY, context.getHandler());
+    if (isPublic) {
+      return true;
+    }
+
+    // TODO: Check if this permission viz. contextPermission is listed in the Public role. 
+    const contextPermission = `${context.getClass().name}.${context.getHandler().name}`;
+
+    const permissionExistsInRole = await this.permissionService.permissionExistsInRole('Public', contextPermission)
+    if (permissionExistsInRole.length > 0) {
+      request['isListedInPublicRole'] = true;
+      return true
+    }
+
+    const authTypes = this.reflector.getAllAndOverride<AuthType[]>(
+      AUTH_TYPE_KEY,
+      [context.getHandler(), context.getClass()],
+    ) ?? [AuthenticationGuard.defaultAuthType];
+    const guards = authTypes.map((type) => this.authTypeGuardMap[type]).flat();
+    let error = new UnauthorizedException();
+
+    for (const instance of guards) {
+      const canActivate = await Promise.resolve(
+        instance.canActivate(context),
+      ).catch((err) => {
+        error = err;
+      });
+
+      if (canActivate) {
+        return true;
+      }
+    }
+    throw error;
+  }
+}

package/src/guards/permissions.guard.ts

@@ -0,0 +1,39 @@
+import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { Observable } from 'rxjs';
+import { ActiveUserData } from '../interfaces/active-user-data.interface';
+import { IS_PUBLIC_KEY } from '../decorators/public.decorator';
+import { REQUEST_USER_KEY } from "../constants";
+
+@Injectable()
+export class PermissionsGuard implements CanActivate {
+    constructor(
+        private readonly reflector: Reflector,
+    ) { }
+
+    canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean> {
+        const isPublic = this.reflector.get(IS_PUBLIC_KEY, context.getHandler());
+        if (isPublic) {
+            return true;
+        }
+
+        // Permission is defined as ControllerName.methodName
+        const contextPermission = `${context.getClass().name}.${context.getHandler().name}`;
+
+        // Check if this permission viz. contextPermission is listed in the Public role. 
+        const request = context.switchToHttp().getRequest();
+        if (request.isListedInPublicRole === true) {
+            return true
+        }
+
+        // Else get hold of the active user & compare what roles they have and basis that return.
+        const user: ActiveUserData = context.switchToHttp().getRequest()[
+            REQUEST_USER_KEY
+        ];
+
+        const userPermissions = user ? user.permissions : [];
+
+        // If the userPermission set includes the context permission, it means they are allowed to access the specified method.
+        return userPermissions.includes(contextPermission);
+    }
+}

package/src/guards/roles.guard.ts

@@ -0,0 +1,37 @@
+/** NOT USED */
+import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { Observable } from 'rxjs';
+import { ROLES_KEY } from '../decorators/roles.decorator';
+import { ActiveUserData } from '../interfaces/active-user-data.interface';
+
+import { REQUEST_USER_KEY } from "../constants";
+
+@Injectable()
+export class RolesGuard implements CanActivate {
+  constructor(private readonly reflector: Reflector) { }
+
+  canActivate(
+    context: ExecutionContext,
+  ): boolean | Promise<boolean> | Observable<boolean> {
+    // Get hold of roles required, as configured at the handler or class level.
+    const contextRoles = this.reflector.getAllAndOverride<string[]>(ROLES_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+
+    // If nothing configured then we assume that all roles are allowed access, hence return true. 
+    if (!contextRoles) {
+      return true;
+    }
+
+    // Else get hold of the active user & compare what roles they have and basis that return.
+    const user: ActiveUserData = context.switchToHttp().getRequest()[
+      REQUEST_USER_KEY
+    ];
+
+    const usersRoles = user ? user.roles : [];
+
+    return contextRoles.some((role) => usersRoles.includes(role));
+  }
+}

package/src/helpers/command.service.ts

@@ -0,0 +1,26 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { exec } from 'child_process';
+
+@Injectable()
+export class CommandService {
+  private readonly logger = new Logger(CommandService.name);
+
+  async executeCommand(command: string): Promise<string> {
+    this.logger.debug(`Executing command :${command}`);
+    return new Promise<string>((resolve, reject) => {
+      exec(command, (error, stdout, stderr) => {
+        if (error) {
+          this.logger.error(`Error executing command :${command}`, error);
+          reject(error);
+          return;
+        }
+        if (stderr) {
+          this.logger.error(`Error executing command :${command}`, stderr);
+          reject(stderr);
+          return;
+        }
+        resolve(stdout);
+      });
+    });
+  }
+}

package/src/helpers/field-crud-managers/BigIntFieldCrudManager.ts

@@ -0,0 +1,55 @@
+import { isEmpty, isNotEmpty, max, min } from "class-validator";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+
+export interface BigIntFieldOptions {
+    min: number | undefined | null; // FIXME Do we want to support min and max for bigint? or number should suffice?
+    max: number | undefined | null; // FIXME Do we want to support min and max for bigint? or number should suffice?
+    required: boolean | undefined | null;
+    fieldName: string;
+}
+
+export class BigIntFieldCrudManager implements FieldCrudManager {
+
+    constructor(private readonly options: BigIntFieldOptions) {
+    }
+
+    validate(createDto: any): ValidationError[] {
+        const fieldValue: any = createDto[this.options.fieldName];
+        return this.applyValidations(fieldValue);
+    }
+
+    private applyValidations(fieldValue: any): ValidationError[] {
+        const errors: ValidationError[] = [];
+        this.isApplyRequiredValidation() && isEmpty(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` }): "no errors";
+        if (isNotEmpty(fieldValue)) {
+            errors.push(...this.applyFormatValidations(fieldValue));
+        }
+        return errors;
+    }
+
+    private applyFormatValidations(fieldValue: any): ValidationError[] {
+        const errors: ValidationError[] = [];
+        !this.isBigInt(fieldValue) ? errors.push({ field: this.options.fieldName, error: 'Field is not a bigint' }): "no errors";
+        this.isApplyMinValidation() && !min(fieldValue, this.options.min) ? errors.push({ field: this.options.fieldName, error: 'Field value is lesser than minimum required' }) : "no errors"; //FIXME min length to be handled
+        this.isApplyMaxValidation() && !max(fieldValue, this.options.max) ? errors.push({ field: this.options.fieldName, error: 'Field value is greater than maximum required' }) : "no errors";
+        return errors;
+    }
+
+    transformForCreate(createDto: any): any {
+        return createDto;
+    }
+
+    // Validation to be applied
+    private isApplyMinValidation(): boolean {
+        return this.options.min > 0;
+    }
+    private isApplyMaxValidation(): boolean {
+        return this.options.max > 0;
+    }
+    private isApplyRequiredValidation(): boolean {
+        return this.options.required;
+    }
+    private isBigInt(value: any): boolean {
+        return typeof value === 'bigint';
+      }
+}

package/src/helpers/field-crud-managers/BooleanFieldCrudManager.ts

@@ -0,0 +1,44 @@
+import { isBoolean, isEmpty, isNotEmpty } from "class-validator";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+
+export interface BooleanFieldOptions {
+    required: boolean | undefined | null;
+    fieldName: string;
+}
+
+export class BooleanFieldCrudManager implements FieldCrudManager {
+    private options: BooleanFieldOptions;
+
+    constructor(options: BooleanFieldOptions) {
+        this.options = options
+    }
+
+    validate(dto: any): ValidationError[] {
+        const fieldValue: any = dto[this.options.fieldName];
+        return this.applyValidations(fieldValue);
+    }
+
+    private applyValidations(fieldValue: any): ValidationError[] {
+        const errors: ValidationError[] = [];
+        this.isApplyRequiredValidation() && isEmpty(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` }): "no errors";
+        if (isNotEmpty(fieldValue)) {
+            errors.push(...this.applyFormatValidations(fieldValue));
+        }
+        return errors;
+    }
+
+    private applyFormatValidations(fieldValue: any): ValidationError[] {
+        const errors: ValidationError[] = [];
+        !isBoolean(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is not a boolean value` }): "no errors";
+        return errors;
+    }
+
+    transformForCreate(dto: any): any {
+        return dto;
+    }
+
+    // Validation to be applied
+    private isApplyRequiredValidation(): boolean {
+        return this.options.required;
+    }
+}

package/src/helpers/field-crud-managers/ComputedFieldCrudManager.ts

@@ -0,0 +1,43 @@
+import { DiscoveryService } from "@nestjs/core";
+import { ComputedFieldValueType } from "src/dtos/create-field-metadata.dto";
+import { FieldCrudManager, IComputedFieldProvider, ValidationError } from "src/interfaces";
+
+export interface ComputedFieldOptions {
+    computedFieldProvider: string;
+    computedFieldValueType: ComputedFieldValueType;
+    computedFieldValueProviderCtxt: any;
+    fieldName: string;
+    discoveryService: DiscoveryService;
+}
+
+export class ComputedFieldCrudManager implements FieldCrudManager {
+
+    constructor(private readonly options: ComputedFieldOptions) {
+    }
+
+    async validate(): Promise<ValidationError[]> {
+        return []; //Since this is a computed field, we can skip the validation, by returning an empty array
+    }
+
+    async transformForCreate(dto: any): Promise<any> {
+        const ctxt = this.options.computedFieldValueProviderCtxt ? JSON.parse(this.options.computedFieldValueProviderCtxt) : {};
+        dto[this.options.fieldName] = await this.computeValue(dto, ctxt);
+        return dto;
+    }
+
+    private async computeValue(dto: any, ctxt: any): Promise<string|number> {
+        const provider = this.providerInstance<any, any>(this.options.computedFieldProvider);
+        return provider.computeValue(dto, ctxt);
+    }
+
+    private providerInstance<DTO, T>(computedFieldProvider: string): IComputedFieldProvider<T> {
+        const provider = this.options.discoveryService
+            .getProviders()
+            .filter((provider) => provider.name === computedFieldProvider) //TODO : Add an extra check to verify if the provider is of type IComputedFieldProvider
+            .pop();
+        if (!provider) {
+            throw new Error(`Provider for ${computedFieldProvider} not found`);
+        }
+        return provider.instance as IComputedFieldProvider<T>;
+    }
+}

package/src/helpers/field-crud-managers/DateFieldCrudManager.ts

@@ -0,0 +1,42 @@
+import { isDate, isEmpty, isNotEmpty } from "class-validator";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+
+export interface DateFieldOptions {
+    required: boolean | undefined | null;
+    fieldName: string;
+}
+
+export class DateFieldCrudManager implements FieldCrudManager {
+
+    constructor(private readonly options: DateFieldOptions) {
+    }
+
+    validate(dto: any): ValidationError[] {
+        const fieldValue: any = dto[this.options.fieldName];
+        return this.applyValidations(fieldValue);
+    }
+
+    private applyValidations(fieldValue: any): ValidationError[] {
+        const errors: ValidationError[] = [];
+        this.isApplyRequiredValidation() && isEmpty(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` }): "no errors";
+        if (isNotEmpty(fieldValue)) {
+            errors.push(...this.applyFormatValidations(fieldValue));
+        }
+        return errors;
+    }
+
+    private applyFormatValidations(fieldValue: any): ValidationError[] {
+        const errors: ValidationError[] = [];
+        !isDate(fieldValue) ? errors.push({ field: this.options.fieldName, error: 'Field is not a date' }) : "no errors";
+        return errors;
+    }
+
+    transformForCreate(dto: any): any {
+        return dto;
+    }
+
+    // Validation to be applied
+    private isApplyRequiredValidation(): boolean {
+        return this.options.required;
+    }
+}