@solidstarters/solid-core 1.2.0

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

@@ -0,0 +1,52 @@
+import { isEmpty, isNotEmpty, isNumber, max, min } from "class-validator";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+
+export interface DecimalFieldOptions {
+    min: number | undefined | null;
+    max: number | undefined | null;
+    required: boolean | undefined | null;
+    fieldName: string;
+}
+
+export class DecimalFieldCrudManager implements FieldCrudManager {
+
+    constructor(private readonly options: DecimalFieldOptions) {
+    }
+
+    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[] = [];
+        !isNumber(fieldValue) ? errors.push({ field: this.options.fieldName, error: 'Field is not a decimal' }): "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;
+    }
+}

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

@@ -0,0 +1,53 @@
+import { isEmail, isEmpty, isNotEmpty, matches } from "class-validator";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+export const MAX_EMAIL_LENGTH = 254;
+
+export interface EmailFieldOptions {
+    max: number | undefined | null;
+    regexPattern: string | undefined | null;
+    required: boolean | undefined | null;
+    fieldName: string;
+}
+
+export class EmailFieldCrudManager implements FieldCrudManager {
+
+    constructor(private readonly options: EmailFieldOptions) {
+    }
+
+    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[] = [];
+        !isEmail(fieldValue) ? errors.push({ field: this.options.fieldName, error: 'Field is not an email' }): "no errors";
+        this.isApplyMaxValidation() && fieldValue.length > this.options.max ? errors.push({ field: this.options.fieldName, error: 'Field is greater than max length' }) : "no errors";
+        this.isApplyRegexValidation() && !matches(fieldValue, new RegExp(this.options.regexPattern)) ? errors.push({ field: this.options.fieldName, error: 'Field does not match regex pattern' }): "no errors";
+        return errors;
+    }
+
+    transformForCreate(dto: any): any {
+        return dto;
+    }
+
+    // Validation to be applied
+    private isApplyRequiredValidation(): boolean {
+        return this.options.required;
+    }
+    private isApplyMaxValidation(): boolean {
+        return (this.options.max > 0);
+    }
+    private isApplyRegexValidation(): boolean {
+        return isNotEmpty(this.options.regexPattern);
+    }
+}

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

@@ -0,0 +1,52 @@
+import { isEmpty, isInt, isNotEmpty, max, min } from "class-validator";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+
+export interface IntFieldOptions {
+    min: number | undefined | null;
+    max: number | undefined | null;
+    required: boolean | undefined | null;
+    fieldName: string;
+}
+
+export class IntFieldCrudManager implements FieldCrudManager {
+
+    constructor(private readonly options: IntFieldOptions) {
+    }
+
+    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[] = [];
+        !isInt(fieldValue) ? errors.push({ field: this.options.fieldName, error: 'Field is not an int' }) : "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"; 
+        (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;
+    }
+}

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

@@ -0,0 +1,42 @@
+import { isEmpty, isJSON, isNotEmpty } from "class-validator";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+
+export interface JsonFieldOptions {
+    required: boolean | undefined | null;
+    fieldName: string | undefined | null;
+}
+
+export class JsonFieldCrudManager implements FieldCrudManager {
+
+    constructor(private readonly options: JsonFieldOptions) {
+    }
+
+    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[] = [];
+        !isJSON(fieldValue) ? errors.push({ field: this.options.fieldName, error: 'Field is not a json object' }) : "no errors";
+        return errors;
+    }
+
+    transformForCreate(createDto: any): any {
+        return createDto;
+    }
+
+    // Validation to be applied
+    private isApplyRequiredValidation(): boolean {
+        return this.options.required;
+    }
+}

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

@@ -0,0 +1,52 @@
+import { isEmpty, isNotEmpty, isString, matches } from "class-validator";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+
+export interface LongTextFieldOptions {
+    regexPattern: string | undefined | null;
+    required: boolean | undefined | null;
+    fieldName: string;
+}
+
+export class LongTextFieldCrudManager implements FieldCrudManager {
+    private options: LongTextFieldOptions;
+
+    constructor(options: LongTextFieldOptions) {
+        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[] = [];
+        this.isApplyStringValidation() && !isString(fieldValue) ? errors.push({ field: this.options.fieldName, error: 'Field is not a string' }) : "no errors";
+        this.isApplyRegexValidation() && !matches(fieldValue, new RegExp(this.options.regexPattern)) ? errors.push({ field: this.options.fieldName, error: 'Field regex pattern is invalid' }) : "no errors";
+        return errors;
+    }
+
+    transformForCreate(dto: any): any {
+        return dto;
+    }
+
+    // Validation to be applied
+    private isApplyStringValidation(): boolean {
+        return true;
+    }
+    private isApplyRegexValidation(): boolean {
+        return this.options.regexPattern !== null && this.options.regexPattern !== undefined && this.options.regexPattern.trim().length > 0;
+    }
+    private isApplyRequiredValidation(): boolean {
+        return this.options.required;
+    }
+}

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

@@ -0,0 +1,199 @@
+import { classify } from "@angular-devkit/core/src/utils/strings";
+import { Logger } from "@nestjs/common";
+import { isEmpty, isEnum, isNotEmpty } from "class-validator";
+import { RelationFieldsCommand } from "src/dtos/create-field-metadata.dto";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+import { EntityManager, In } from "typeorm";
+
+export interface ManyToManyRelationFieldOptions {
+    // Add options for relation field
+    required: boolean | undefined | null;
+    relationModelSingularName: string | undefined | null;
+    modelSingularName: string | undefined | null;
+    isInverseSide: boolean;
+    entityManager: EntityManager;
+    fieldName: string;
+    relationModelFieldName?: string;
+}
+
+const linkCommands = [RelationFieldsCommand.link, RelationFieldsCommand.unlink, RelationFieldsCommand.set];
+
+// This implementation is meant to be used for many-to-one relation field
+export class ManyToManyRelationFieldCrudManager implements FieldCrudManager {
+    private readonly logger = new Logger(ManyToManyRelationFieldCrudManager.name);
+
+    private valueFieldName: string;
+    private idFieldName: string;
+    private commandFieldName: string;
+
+    constructor(private readonly options: ManyToManyRelationFieldOptions) {
+        if (!this.options.isInverseSide) {
+            this.valueFieldName = `${this.options.fieldName}`;
+            this.idFieldName = `${this.options.fieldName}Ids`;
+            this.commandFieldName = `${this.options.fieldName}Command`;
+        }
+        else {
+            this.valueFieldName = `${this.options.relationModelFieldName}`;
+            this.idFieldName = `${this.options.relationModelFieldName}Ids`;
+            this.commandFieldName = `${this.options.relationModelFieldName}Command`;
+        }
+    }
+
+    validate(dto: any) {
+        return this.applyValidations(dto);
+    }
+
+    private applyValidations(dto: any): ValidationError[] { 
+        const errors: ValidationError[] = [];
+
+        const commandFieldName = this.commandFieldName;
+        const commandValue = dto[commandFieldName];
+        this.isApplyRequiredValidation() && isEmpty(commandValue) ? errors.push({ field: commandFieldName, error: 'Command field is required' }) : "no errors";
+        if (isNotEmpty(commandValue)) {
+            !isEnum(commandValue, RelationFieldsCommand)? errors.push({ field: this.options.fieldName, error: 'Command Field has invalid value' }) : "no errors";
+        }  
+       
+        var fieldValue = null
+        if (commandValue === RelationFieldsCommand.clear) {
+            return errors;
+        } else if (linkCommands.includes(commandValue)) {
+            fieldValue = dto[this.idFieldName];
+        } 
+        else {
+            fieldValue = dto[this.valueFieldName];
+        }
+
+        this.isApplyRequiredValidation() && isEmpty(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` }) : "no errors";
+        return errors;
+    }
+
+    async transformForCreate(dto: any): Promise<any> {
+        const currentEntityTarget = this.getEntityTarget(classify(this.options.modelSingularName));
+        const currentEntityRepository = this.options.entityManager.getRepository(currentEntityTarget);
+
+        const relatedEntityTarget = this.getEntityTarget(classify(this.options.relationModelSingularName));
+        const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityTarget)
+
+        dto[this.valueFieldName] = await this.transformByCommand(dto, relatedEntityRepository, currentEntityRepository);
+        return dto;
+    }
+
+    private async transformByCommand(dto: any, relatedEntityRepository: any, currentEntityRepository: any): Promise<any[]> {
+        // TODO : Need to add support for the multiple commands
+        const command = dto[this.commandFieldName];
+        const values = dto[this.valueFieldName];
+        const ids = dto[this.idFieldName];
+        
+        switch (command) {
+            case RelationFieldsCommand.create:
+                return await this.transformForCommandCreate(values, relatedEntityRepository);
+            case RelationFieldsCommand.update:
+                return await this.transformForCommandUpdate(values, relatedEntityRepository, dto, currentEntityRepository);
+            case RelationFieldsCommand.delete:
+                return await this.transformForCommandDelete(values, relatedEntityRepository);
+            case RelationFieldsCommand.clear:
+                return this.transformForCommandClear();
+            case RelationFieldsCommand.set:
+                return await this.transformForCommandSet(ids, relatedEntityRepository, dto, currentEntityRepository);    
+            case RelationFieldsCommand.link:
+                return await this.tranformForCommandLink(ids, relatedEntityRepository, dto, currentEntityRepository);
+            case RelationFieldsCommand.unlink:
+                return await this.transformForCommandUnLink(ids, relatedEntityRepository, dto, currentEntityRepository);
+            default:
+                this.logger.log(`Invalid command ${command}`);
+                return null;
+                
+        }
+    }
+
+    private transformForCommandClear() {
+        return []
+    }
+
+    private async transformForCommandSet(ids: any[], relatedEntityRepository: any,  dto: any, currentEntityRepository: any): Promise<any[]> {
+        // Load the entities with the ids passed
+        const loadedEntities: any[] = await relatedEntityRepository.find({
+            where : {id: In(ids) } 
+        })
+        if (loadedEntities.length !== ids.length) {
+            throw new Error('Invalid entity ids provided for linking');
+        }
+
+        return loadedEntities;
+    }
+
+    private async tranformForCommandLink(ids: any, relatedEntityRepository: any, dto: any, currentEntityRepository: any) {
+        const tranformedRelatedFields = [];
+        // Load the entities with the ids passed
+        const loadedEntities: any[] = await relatedEntityRepository.find({
+            where : {id: In(ids) } 
+        })
+        if (loadedEntities.length !== ids.length) {
+            throw new Error('Invalid entity ids provided for linking');
+        }
+        tranformedRelatedFields.push(...loadedEntities);
+
+        return tranformedRelatedFields;
+    }
+
+    private async transformForCommandUnLink(ids: any, relatedEntityRepository: any, dto: any, currentEntityRepository: any) {
+        if (dto.id == null) {
+            throw new Error('Entity id is required for unlinking');
+        } 
+
+        const tranformedRelatedFields = [];
+        const entityInstance = await currentEntityRepository.findOne({
+            where: {id: dto.id},
+            relations: [this.valueFieldName]
+        });
+        const filteredEntities = entityInstance[this.valueFieldName].filter((entity) => !ids.includes(entity.id));
+        tranformedRelatedFields.push(...filteredEntities);
+
+        return tranformedRelatedFields;
+    }
+
+    private async transformForCommandCreate(values: any[], relatedEntityRepository: any): Promise<any[]> {
+        const transformedRelatedFields = [];
+        for (const entity of values) {
+            const transformed = relatedEntityRepository.create(entity);
+            transformedRelatedFields.push(transformed);
+       }
+        return transformedRelatedFields;
+    }
+
+    private async transformForCommandUpdate(values: any[], relatedEntityRepository: any, dto: any, currentEntityRepository: any): Promise<any[]> {
+        const transformedRelatedFields = [];
+        for (const entity of values) {
+            if (entity.id) {
+                const transformed = await relatedEntityRepository.preload(entity);
+                transformedRelatedFields.push(transformed);
+            }
+            else {
+                const transformed = relatedEntityRepository.create(entity);
+                transformedRelatedFields.push(transformed);
+            }
+        }
+
+        return transformedRelatedFields;
+    }
+
+    private async transformForCommandDelete(values: any[], relatedEntityRepository: any): Promise<any[]> {
+        // Map and get the ids from the values
+        const ids = values.map((value) => value.id);
+
+        // Delete the ids linked to the associated entity
+        await relatedEntityRepository.delete(ids);
+        return null
+    }
+
+    private isApplyRequiredValidation(): boolean {
+        return this.options.required;
+    }
+
+    // Returns the entity target class from the entity name
+    private getEntityTarget(entityName: string): any { //TODO Can be refactored to use this function from crud helper service
+        const entityMetadatas = this.options.entityManager.connection.entityMetadatas;
+        const entityMetadata = entityMetadatas.find(em => em.name === entityName);
+        return entityMetadata.target;
+    }
+}

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

@@ -0,0 +1,96 @@
+import { classify } from "@angular-devkit/core/src/utils/strings";
+import { isEmpty, isNotEmpty, isString } from "class-validator";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+import { IsParsableInt } from "src/validators/is-parsable-int";
+import { EntityManager } from "typeorm";
+
+export interface ManyToOneRelationFieldOptions {
+    // Add options for relation field
+    required: boolean | undefined | null;
+    relationModelSingularName: string | undefined | null;
+    fieldName: string | undefined | null;
+    modelUserKeyFieldName: string | undefined | null;
+    modelSingularName: string | undefined | null;
+    entityManager: EntityManager;
+}
+
+// This implementation is meant to be used for many-to-one relation field
+export class ManyToOneRelationFieldCrudManager implements FieldCrudManager {
+    private idFieldName: string;
+    private userKeyFieldName: string;
+    constructor(private readonly options: ManyToOneRelationFieldOptions) {
+        // this.options = options;
+        this.idFieldName = `${options.fieldName}Id`;
+        this.userKeyFieldName = `${options.fieldName}UserKey`;
+    }
+    validate(dto: any) {
+        const fieldId: number = dto[this.idFieldName];
+        const fieldUserKey: string = dto[this.userKeyFieldName];
+        return this.applyValidations(fieldId, fieldUserKey);
+    }
+
+    private applyValidations(fieldId: any, fieldUserKey: string): ValidationError[] {
+        const errors: ValidationError[] = [];
+        this.isApplyRequiredValidation() && isEmpty(fieldId) && isEmpty(fieldUserKey) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required. Either pass ${this.idFieldName} or ${this.userKeyFieldName}.` }) : "no errors";
+        if (isNotEmpty(fieldId)) {
+            errors.push(...this.applyIdFormatValidations(fieldId));
+        }
+        if (isNotEmpty(fieldUserKey)) {
+            errors.push(...this.applyUserKeyFormatValidations(fieldUserKey));
+        }
+        return errors;
+    }
+
+    private applyIdFormatValidations(fieldId: any): ValidationError[] { //FIXME fieldId is any because it can be string or number. Keeping it any for compatibility with isParsableInt. 
+        const errors: ValidationError[] = [];
+        !IsParsableInt(fieldId) ? errors.push({ field: this.options.fieldName, error: 'Field is not a integer' }) : "no errors";
+        return errors;
+    }
+
+    private applyUserKeyFormatValidations(fieldUserKey: string): ValidationError[] {
+        const errors: ValidationError[] = [];
+        !isString(fieldUserKey) ? errors.push({ field: this.options.fieldName, error: 'Field is not a string' }) : "no errors";
+        if (isEmpty(this.options.modelUserKeyFieldName)) {
+            errors.push({ field: this.options.fieldName, error: `UserKey field name is not defined in the model ${this.options.modelSingularName}` });
+        }
+        return errors;
+    }
+
+    async transformForCreate(dto: any): Promise<any> {
+        const fieldId: number = dto[this.idFieldName];
+        const fieldUserKeyValue: string = dto[this.userKeyFieldName];
+
+        // Avoid transforming if both fieldId and fieldUserKey  is empty
+        if ((isEmpty(fieldId)) && isEmpty(fieldUserKeyValue)) return dto;
+
+        // // Load the related entity from the database, using the repository of the related entity
+        const entityTarget = this.getRelatedEntityTarget(classify(this.options.relationModelSingularName));
+        if (isNotEmpty(fieldId)) {
+            dto[this.options.fieldName] = await this.options.entityManager.getRepository(entityTarget).findOneBy({ id: fieldId });
+            if (this.options.required && isEmpty(dto[this.options.fieldName])) {
+                throw new Error(`ManyToOneRelationFieldCrudManager: Record with id: ${fieldId} not found in ${this.options.relationModelSingularName}`);
+            }
+        }
+        else {
+            dto[this.options.fieldName] = await this.options.entityManager.getRepository(entityTarget).findOneBy({ [this.options.modelUserKeyFieldName]: fieldUserKeyValue });
+            if (this.options.required && isEmpty(dto[this.options.fieldName])) {
+                throw new Error(`ManyToOneRelationFieldCrudManager: Record with userKey: ${this.options.modelUserKeyFieldName}: ${fieldUserKeyValue} not found in ${this.options.relationModelSingularName}`);
+            }
+        }
+
+
+        return dto;
+    }
+
+    private isApplyRequiredValidation(): boolean {
+        return this.options.required;
+    }
+
+    // Returns the entity target class from the entity name
+    private getRelatedEntityTarget(relatedEntityName: string): any {
+        const entityMetadatas = this.options.entityManager.connection.entityMetadatas;
+        const relatedEntityMetadata = entityMetadatas.find(em => em.name === relatedEntityName);
+        return relatedEntityMetadata.target;
+    }
+
+}

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

@@ -0,0 +1,69 @@
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+
+export enum SolidMediaType {
+    mediaSingle = 'mediaSingle',
+    mediaMultiple = 'mediaMultiple'
+}
+
+export interface MediaFieldOptions {
+    type: SolidMediaType;
+    required: boolean | undefined | null;
+    fieldName: string | undefined | null;
+}
+
+export class MediaFieldCrudManager implements FieldCrudManager {
+
+    constructor(private readonly options: MediaFieldOptions) {
+    }
+
+    validate(dto: any, files:Array<Express.Multer.File>): ValidationError[] {
+        const isValidateForUpdate = dto.id !== undefined; //FIXME: This is a hack, since we are using PUT for update. Once we support PATCH, this will be removed
+        const fieldFiles = files.filter(file => file.fieldname === this.options.fieldName);
+        return this.applyValidations(fieldFiles, isValidateForUpdate);
+    }
+
+    private applyValidations(fieldFiles:Array<Express.Multer.File>, isValidateForUpdate: boolean): ValidationError[] {
+        switch (this.options.type) {
+            case SolidMediaType.mediaSingle:
+                return this.validateMediaSingle(fieldFiles, isValidateForUpdate);
+            case SolidMediaType.mediaMultiple:
+                return this.validateMediaMultiple(fieldFiles, isValidateForUpdate);
+            default:
+                return [];
+        }
+    }
+
+    private validateMediaSingle(fieldFiles:Array<Express.Multer.File>, isValidateForUpdate: boolean): ValidationError[] {
+        const errors: ValidationError[] = [];
+        if (!isValidateForUpdate && this.options.required && fieldFiles.length === 0) {
+            errors.push({
+                field: this.options.fieldName,
+                error: `${this.options.fieldName} is required`
+            });
+        }
+        if (fieldFiles.length > 1) {
+            errors.push({
+                field: this.options.fieldName,
+                error: `${this.options.fieldName} must be a single file`
+            });
+        }
+        return errors;
+    }
+
+    private validateMediaMultiple(fieldFiles:Array<Express.Multer.File>, isValidateForUpdate: boolean): ValidationError[] {    
+        const errors: ValidationError[] = [];
+        if (!isValidateForUpdate && this.options.required && fieldFiles.length === 0) {
+            errors.push({
+                field: this.options.fieldName,
+                error: `${this.options.fieldName} is required`
+            });
+        }
+        return errors;
+    }
+
+    transformForCreate(dto: any): any {
+        return dto;
+    }
+
+    // Validation to be applied
+}

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

@@ -0,0 +1,13 @@
+import { FieldCrudManager } from "src/interfaces";
+
+export class NoOpsFieldCrudManager implements FieldCrudManager{
+    createDto: any;
+    constructor(){
+    }
+    validate(dto: any) {
+        return [];
+    }
+    transformForCreate(dto: any) {
+        return dto;
+    }
+}