@solidstarters/solid-core 1.2.0

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

@@ -0,0 +1,204 @@
+import { classify } from "@angular-devkit/core/src/utils/strings";
+import { isEmpty, isEnum, isInt, isNotEmpty } from "class-validator";
+import { RelationFieldsCommand } from "src/dtos/create-field-metadata.dto";
+import { FieldMetadata } from "src/entities/field-metadata.entity";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+import { EntityManager, In } from "typeorm";
+
+export interface OneToManyRelationFieldOptions {
+    // Add options for relation field
+    required: boolean | undefined | null;
+    relationModelSingularName: string | undefined | null;
+    inverseRelationModelFieldName: string | undefined | null;
+    modelSingularName: string | undefined | null;
+    inverseFieldName: string | undefined | null;
+    entityManager: EntityManager | undefined | null;
+}
+
+const linkCommands = [RelationFieldsCommand.link, RelationFieldsCommand.unlink, RelationFieldsCommand.set];
+
+// This implementation is meant to be used for many-to-one relation field
+export class OneToManyRelationFieldCrudManager implements FieldCrudManager {
+
+    private readonly valueFieldName: string;
+    private readonly idFieldName: string;
+    private readonly commandFieldName: string;
+
+    constructor(private readonly options: OneToManyRelationFieldOptions) {
+        this.valueFieldName = this.options.inverseRelationModelFieldName ?? `${this.options.relationModelSingularName}s`;
+        this.idFieldName = `${this.options.inverseRelationModelFieldName ?? this.options.relationModelSingularName}Ids`;
+        this.commandFieldName = `${this.options.inverseRelationModelFieldName ?? this.options.relationModelSingularName}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.inverseFieldName, 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.inverseFieldName, error: `Field: ${this.options.inverseFieldName} is required` }) : "no errors";
+        if (isNotEmpty(fieldValue)) {
+            errors.push(...this.applyFormatValidations(fieldValue, commandValue, commandFieldName));
+        }
+        return errors;
+    }
+
+    private applyFormatValidations(fieldValue: any[], commandValue: RelationFieldsCommand, commandFieldName: string): ValidationError[] {
+        const errors: ValidationError[] = [];
+        if (linkCommands.includes(commandValue)) {
+            for (const id of fieldValue) {
+                if (!isInt(id)) {
+                    errors.push({ field: this.options.inverseFieldName, error: `Invalid ids in ${commandFieldName}` });
+                }
+            }
+        }
+        return errors;
+    }
+
+    async transformForCreate(dto: any): Promise<any> {
+        // const relatedFieldData: any[] = dto[this.fieldName()];
+        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:
+                return null; // This is equivalent to no transformation
+        }
+    }
+
+    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/PasswordFieldCrudManager.ts

@@ -0,0 +1,70 @@
+import { isEmpty, isNotEmpty, isString, matches, max, min } from "class-validator";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+import { BcryptService } from "src/services/bcrypt.service";
+import { HashingService } from "src/services/hashing.service";
+
+export interface PasswordFieldOptions {
+    min: number | undefined | null;
+    max: number | undefined | null;
+    required: boolean | undefined | null;
+    regexPattern: string | undefined | null;
+    fieldName: string | undefined | null;
+}
+
+export class PasswordFieldCrudManager implements FieldCrudManager {
+    private hashingService: HashingService = new BcryptService(); //FIXME: The bcrypt service injected here probably can be optimized to be a singleton
+
+    constructor(private readonly options: PasswordFieldOptions) {
+    }
+
+    validate(dto: any): ValidationError[] {
+        const fieldValue: any = dto[this.options.fieldName];
+        return this.applyValidations(fieldValue, dto);
+    }
+
+    private applyValidations(fieldValue: any, dto: 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, dto));
+        }
+        return errors;
+    }
+
+    private applyFormatValidations(fieldValue: any, dto:any): ValidationError[] {
+        const errors: ValidationError[] = [];
+        !isString(fieldValue) ? errors.push({ field: this.options.fieldName, error: 'Field is not a string' }) : "no errors";
+        !this.isPasswordValid(fieldValue) ? errors.push({ field: this.options.fieldName, error: 'Password regex pattern is invalid' }) : "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";
+        !this.isConfirmPasswordValid(dto) ? errors.push({ field: this.options.fieldName, error: 'Password and confirm password do not match' }) : "no errors";
+        return errors;
+    }
+
+    async transformForCreate(dto: any): Promise<any> {
+        if(dto[this.options.fieldName]){
+            dto[this.options.fieldName] = await this.hashingService.hash(dto[this.options.fieldName]);
+        }
+        return dto;
+    }
+
+    // Validation to be applied
+    private isApplyMinValidation(): boolean {
+        return this.options.min > 0;
+    }
+    private isApplyMaxValidation(): boolean {
+        return this.options.max > 0;
+    }
+    private isPasswordValid(password: string): boolean {
+        return matches(password, new RegExp(this.options.regexPattern ?? String.raw`^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\da-zA-Z]).*$`)); 
+    }
+    private isConfirmPasswordValid(dto: any): boolean {
+        const passwordFieldName = this.options.fieldName;
+        const confirmPasswordFieldName = `${passwordFieldName}Confirm`;
+        return dto[passwordFieldName] === dto[confirmPasswordFieldName];
+    }
+
+    private isApplyRequiredValidation(): boolean {
+        return this.options.required;
+    }
+}

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

@@ -0,0 +1,50 @@
+import { isEmpty, isNotEmpty, isString, matches } from "class-validator";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+
+export interface RichTextFieldOptions {
+    regexPattern: string | undefined | null;
+    required: boolean | undefined | null;
+    fieldName: string | undefined | null;
+}
+
+export class RichTextFieldCrudManager implements FieldCrudManager {
+
+    constructor(private readonly options: RichTextFieldOptions) {
+    }
+
+    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/SelectionDynamicFieldCrudManager.ts

@@ -0,0 +1,80 @@
+import { DiscoveryService } from "@nestjs/core";
+import { isEmpty, isInt, isNotEmpty, isString } from "class-validator";
+import { SelectionValueType } from "src/dtos/create-field-metadata.dto";
+import { FieldCrudManager, ISelectionProvider, ISelectionProviderContext, ValidationError } from "src/interfaces";
+
+export interface SelectionDynamicFieldOptions {
+    selectionDynamicProvider: string;
+    selectionValueType: SelectionValueType;
+    required: boolean | undefined | null;
+    selectionDynamicProviderCtxt: any;
+    fieldName: string;
+    discoveryService: DiscoveryService;
+}
+
+export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
+
+    constructor(private readonly options: SelectionDynamicFieldOptions) {
+    }
+
+    async validate(dto: any): Promise<ValidationError[]> {
+        const fieldValue: any = dto[this.options.fieldName];
+        return this.applyValidations(fieldValue);
+    }
+
+    private async applyValidations(fieldValue: any): Promise<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)) {
+            const formatErrors = await this.applyFormatValidations(fieldValue);
+            errors.push(...formatErrors);
+        }
+        return errors;
+    }
+
+    private async applyFormatValidations(fieldValue: any): Promise<ValidationError[]> {
+        const errors: ValidationError[] = [];
+        !this.isValidSelectionValueType(fieldValue, this.options.selectionValueType) ? errors.push({ field: this.options.fieldName, error: 'Field value type is invalid' }) : "no errors";
+        const _isValidSelectionValue = await this.isValidSelectionValue(fieldValue, this.options.selectionDynamicProvider)
+        !_isValidSelectionValue ? errors.push({ field: this.options.fieldName, error: 'Field value is invalid' }) : "no errors";
+        return errors;
+    }
+
+    transformForCreate(dto: any): any {
+        return dto;
+    }
+
+    // Validation to be applied
+    private isValidSelectionValueType(fieldValue: any, selectionValueType: SelectionValueType): boolean {
+        switch (selectionValueType) {
+            case SelectionValueType.string:
+                return isString(fieldValue);
+            case SelectionValueType.int:
+                return isInt(fieldValue);
+            default:
+                throw new Error(`Validation for selection value type ${selectionValueType} is not implemented`);
+        }
+    }
+
+    private async isValidSelectionValue(fieldValue: any, selectionDynamicProvider: string): Promise<boolean> {
+        const providerInstance = this.providerInstance<any>(selectionDynamicProvider);
+        const values = await providerInstance.values('', this.options.selectionDynamicProviderCtxt);
+        // return values.map(v => v.split(":")[0]).includes(fieldValue);
+        return values.map(v => v.value).includes(fieldValue);
+    }
+
+    private providerInstance<T extends ISelectionProviderContext>(selectionDynamicProvider: string): ISelectionProvider<T> {
+        const provider = this.options.discoveryService
+            .getProviders()
+            .filter((provider) => provider.name === selectionDynamicProvider)
+            .pop();
+        if (!provider) {
+            throw new Error(`Provider for ${selectionDynamicProvider} not found`);
+        }
+        return provider.instance as ISelectionProvider<T>;
+    }
+
+    private isApplyRequiredValidation(): boolean {
+        return this.options.required;
+    }
+}

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

@@ -0,0 +1,68 @@
+import { isEmpty, isInt, isNotEmpty, isString } from "class-validator";
+import { SelectionValueType } from "src/dtos/create-field-metadata.dto";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+
+export interface SelectionStaticFieldOptions {
+    selectionStaticValues: string[];
+    selectionValueType: SelectionValueType;
+    required: boolean | undefined | null;
+    fieldName: string;
+}
+
+export class SelectionStaticFieldCrudManager implements FieldCrudManager {
+
+    constructor(private readonly options: SelectionStaticFieldOptions) {
+    }
+
+    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.isValidSelectionValueType(fieldValue, this.options.selectionValueType) ? errors.push({ field: this.options.fieldName, error: 'Field value is invalid' }) : "no errors";
+        !this.isValidSelectionStaticValue(fieldValue, this.options.selectionValueType, this.options.selectionStaticValues) ? errors.push({ field: this.options.fieldName, error: 'Field value is invalid' }) : "no errors";
+        return errors;
+    }
+
+    transformForCreate(dto: any): any {
+        return dto;
+    }
+
+    // Validation to be applied
+    private isValidSelectionValueType(fieldValue: any, selectionValueType: SelectionValueType): boolean {
+        switch (selectionValueType) {
+            case SelectionValueType.string:
+                return isString(fieldValue);
+            case SelectionValueType.int:
+                return isInt(fieldValue);
+            default:
+                throw new Error(`Validation for selection value type ${selectionValueType} is not implemented`);
+        }
+    }
+
+    private isValidSelectionStaticValue(fieldValue: any, selectionValueType: any, selectionStaticValues: string[]): boolean {
+        switch (selectionValueType) {
+            case SelectionValueType.string:
+                return selectionStaticValues.map(v => v.split(":")[0]).includes(fieldValue);
+            case SelectionValueType.int:
+                return selectionStaticValues.map(v => Number(v.split(":")[0])).includes(fieldValue);
+            default:
+                throw new Error(`Validation for selection value type ${selectionValueType} is not implemented`);
+        }
+    }
+
+    private isApplyRequiredValidation(): boolean {
+        return this.options.required;
+    }
+}

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

@@ -0,0 +1,58 @@
+import { isEmpty, isNotEmpty, isString, length, matches } from "class-validator";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+
+export interface ShortTextFieldOptions {
+    length: number | undefined | null;
+    regexPattern: string | undefined | null;
+    required: boolean | undefined | null;
+    fieldName: string;
+}
+
+export class ShortTextFieldCrudManager implements FieldCrudManager {
+    private options: ShortTextFieldOptions;
+
+    constructor(options: ShortTextFieldOptions) {
+        this.options = options;
+    }
+
+    validate(dto: any,  _files:Array<Express.Multer.File>): 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.isApplyLengthValidation() && !length(fieldValue, 1, this.options.length) ? errors.push({ field: this.options.fieldName, error: 'Field length is invalid' }) : "no errors"; //FIXME min length to be handled
+        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 isApplyLengthValidation(): boolean {
+        return (this.options.length > 0);
+    }
+    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/UUIDFieldCrudManager.ts

@@ -0,0 +1,49 @@
+import { isEmpty, isNotEmpty, matches } from "class-validator";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+import { v4 as uuidv4 } from 'uuid';
+
+
+const UUID_REGEX = `^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$`;
+
+export interface UUIDFieldOptions {
+    fieldName: string;
+}
+
+//TODO Do we want to provide option to generate uuid of a particular length?
+export class UUIDFieldCrudManager implements FieldCrudManager {
+    constructor(private readonly options: UUIDFieldOptions) { }
+
+    validate(dto: any): ValidationError[] {
+        const fieldValue: any = dto[this.options.fieldName];
+        return this.applyValidations(fieldValue);
+    }
+
+    private applyValidations(fieldValue: any): ValidationError[] {
+        const errors: ValidationError[] = [];
+        if (isNotEmpty(fieldValue)) {
+            errors.push(...this.applyFormatValidations(fieldValue));
+        }
+        return errors;
+    }
+
+    private applyFormatValidations(fieldValue: any): ValidationError[] {
+        const errors: ValidationError[] = [];
+        !this.isUUID(fieldValue) ? errors.push({ field: this.options.fieldName, error: `${this.options.fieldName} is not a valid UUID` }) : "no errors";
+        return errors;
+    }
+
+    transformForCreate(dto: any): any {
+        const fieldValue: any = dto[this.options.fieldName];
+        if (isEmpty(fieldValue)) dto[this.options.fieldName] = this.generateUUID(); 
+        return dto;
+    }
+
+    // Validation to be applied
+    private isUUID(fieldValue: string): boolean {
+        return matches(fieldValue, new RegExp(UUID_REGEX));
+    }
+    private generateUUID(): string {
+        return uuidv4();
+    }
+
+}

package/src/helpers/module.helper.ts

@@ -0,0 +1,25 @@
+import * as fs from 'fs'; // Use the Promise-based version of fs for async/await
+import * as path from 'path'; // To handle file paths
+
+
+export const getDynamicModuleNames = (): string[] => {
+    const dynamicModulesToExclude = process.env.SOLID_DYNAMIC_MODULES_TO_EXCLUDE?.split(',') || [];
+  
+    // Adjust if 'src' is in a different location
+    const srcPath = path.join(process.cwd(), 'src');
+    const coreModuleNames = getCoreModuleNames();
+    const allExcludedModules = [...new Set([...coreModuleNames, ...dynamicModulesToExclude])];
+  
+    const directories = fs.readdirSync(srcPath, { withFileTypes: true });
+    const enabledModules = directories
+      .filter(d => d.isDirectory() && !allExcludedModules.includes(d.name))
+      .map(d => d.name);
+  
+    console.log(`Enabled dynamic modules:`, enabledModules);
+    return enabledModules;
+  }
+  
+  export const getCoreModuleNames = (): string[] => {
+    // return ['iam', 'common', 'queues', 'app-builder'];
+    return ['solid-core'];
+  }