@solidstarters/solid-core 1.2.97 → 1.2.99

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.97",
+  "version": "1.2.99",
   "description": "This module is a NestJS module containing all the required core providers required by a Solid application",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/controllers/action-metadata.controller.ts

@@ -7,7 +7,7 @@ import { UpdateActionMetadataDto } from '../dtos/update-action-metadata.dto';
 import { SolidRequestContextDto } from 'src/dtos/solid-request-context.dto';
 import { SolidRequestContextDecorator } from 'src/decorators/solid-request-context.decorator';
 
-@ApiTags('App')
+@ApiTags('App Builder')
 @Controller('action-metadata') //FIXME: Change this to the model plural name 
 export class ActionMetadataController {
   constructor(private readonly service: ActionMetadataService) { }

package/src/controllers/export-template.controller.ts

@@ -7,7 +7,7 @@ import { UpdateExportTemplateDto } from '../dtos/update-export-template.dto';
 import { Response } from 'express';
 import { StartExportSyncDto } from 'src/dtos/export.dto';
 
-@ApiTags('Solid') 
+@ApiTags('Solid Core') 
 @Controller('export-template') //FIXME: Change this to the model plural name 
 export class ExportTemplateController { 
   constructor(private readonly service: ExportTemplateService) {}

package/src/controllers/export-transaction.controller.ts

@@ -5,7 +5,7 @@ import { ExportTransactionService } from '../services/export-transaction.service
 import { CreateExportTransactionDto } from '../dtos/create-export-transaction.dto';
 import { UpdateExportTransactionDto } from '../dtos/update-export-transaction.dto';
 
-@ApiTags('Solid') 
+@ApiTags('Solid Core') 
 @Controller('export-transaction') //FIXME: Change this to the model plural name 
 export class ExportTransactionController {
   constructor(private readonly service: ExportTransactionService) {}

package/src/controllers/menu-item-metadata.controller.ts

@@ -9,7 +9,7 @@ import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
 import { SolidRequestContextDto } from 'src/dtos/solid-request-context.dto';
 import { SolidRequestContextDecorator } from 'src/decorators/solid-request-context.decorator';
 
-@ApiTags('App')
+@ApiTags('App Builder')
 @Controller('menu-item-metadata') //FIXME: Change this to the model plural name 
 export class MenuItemMetadataController {
   constructor(private readonly service: MenuItemMetadataService) { }

package/src/controllers/permission-metadata.controller.ts

@@ -7,7 +7,7 @@ import { UpdatePermissionMetadataDto } from '../dtos/update-permission-metadata.
 import { SolidRequestContextDto } from 'src/dtos/solid-request-context.dto';
 import { SolidRequestContextDecorator } from 'src/decorators/solid-request-context.decorator';
 
-@ApiTags('Solid')
+@ApiTags('Solid Core')
 @Controller('permission-metadata') //FIXME: Change this to the model plural name 
 export class PermissionMetadataController {
   constructor(private readonly service: PermissionMetadataService) { }

package/src/controllers/role-metadata.controller.ts

@@ -7,7 +7,7 @@ import { UpdateRoleMetadataDto } from '../dtos/update-role-metadata.dto';
 import { SolidRequestContextDto } from 'src/dtos/solid-request-context.dto';
 import { SolidRequestContextDecorator } from 'src/decorators/solid-request-context.decorator';
 
-@ApiTags('Solid') 
+@ApiTags('Solid Core') 
 @Controller('role-metadata') //FIXME: Change this to the model plural name 
 export class RoleMetadataController {
   constructor(private readonly service: RoleMetadataService) {}

package/src/controllers/service.controller.ts

@@ -1,4 +1,4 @@
-import { Controller, Get } from '@nestjs/common';
+import { Body, Controller, Get, Logger, Post } from '@nestjs/common';
 import { DiscoveryService, MetadataScanner, Reflector } from '@nestjs/core';
 import { Public } from 'src/decorators/public.decorator';
 import { SolidRegistry } from '../helpers/solid-registry';
@@ -8,6 +8,8 @@ import { ApiTags } from '@nestjs/swagger';
 @Controller('')
 @ApiTags("Common")
 export class ServiceController {
+    private readonly logger = new Logger(ServiceController.name);
+
     constructor(
         private readonly solidRegistry: SolidRegistry,
     ) { }
@@ -18,6 +20,23 @@ export class ServiceController {
         return { pong: 'v1.0.2' };
     }
 
+    @Public()
+    @Post('seed')
+    async seedData(@Body() seedData: any) {
+        const seeder = this.solidRegistry
+            .getSeeders()
+            .filter((seeder) => seeder.name === seedData.seeder)
+            .map((seeder) => seeder.instance)
+            .pop();
+        if (!seeder) {
+            this.logger.error(`Seeder service ${seedData.seeder} not found. Does your service have a seed() method?`);
+            return;
+        }
+        this.logger.log(`Running the seed() method for seeder :${seeder.constructor.name}`);
+        await seeder.seed();
+        return { message: `seed data for ${seedData.seeder}` };
+    }
+
     // @Public()
     // @Get('play')
     // play() {

package/src/controllers/setting.controller.ts

@@ -8,7 +8,7 @@ import { SolidRequestContextDecorator } from 'src/decorators/solid-request-conte
 import { SolidRequestContextDto } from 'src/dtos/solid-request-context.dto';
 import { UpdateSettingsDto } from 'src/dtos/update-settings.dto';
 
-@ApiTags('Solid') 
+@ApiTags('Solid Core') 
 @Controller('setting') //FIXME: Change this to the model plural name 
 export class SettingController {
   constructor(private readonly service: SettingService) {}
@@ -88,7 +88,8 @@ export class SettingController {
 
   @ApiBearerAuth("jwt")
   @Post('/bulk-update')
-  async updateSettings(@Body() updateSettingsDto: UpdateSettingsDto) {
-    return this.service.updateSettings(updateSettingsDto.settings);
+  @UseInterceptors(AnyFilesInterceptor())
+  async updateSettings(@Body() updateSettingsDto: UpdateSettingsDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.updateSettings(updateSettingsDto.settings, files);
   }
 }

package/src/controllers/test.controller.ts

@@ -34,21 +34,21 @@ export class TestController {
     return { filename: file.originalname };
   }
 
-  @Public()
-  @Post('seed')
-  async seedData(@Body() seedData: any) {
-    const seeder = this.solidRegistry
-      .getSeeders()
-      .filter((seeder) => seeder.name === seedData.seeder)
-      .map((seeder) => seeder.instance)
-      .pop();
-    if (!seeder) {
-      this.logger.error(`Seeder service ${seedData.seeder} not found. Does your service have a seed() method?`);
-      return;
-    }
-    this.logger.log(`Running the seed() method for seeder :${seeder.constructor.name}`);
-    await seeder.seed();
-    return { message: `seed data for ${seedData.seeder}` };
-  }
+  // @Public()
+  // @Post('seed')
+  // async seedData(@Body() seedData: any) {
+  //   const seeder = this.solidRegistry
+  //     .getSeeders()
+  //     .filter((seeder) => seeder.name === seedData.seeder)
+  //     .map((seeder) => seeder.instance)
+  //     .pop();
+  //   if (!seeder) {
+  //     this.logger.error(`Seeder service ${seedData.seeder} not found. Does your service have a seed() method?`);
+  //     return;
+  //   }
+  //   this.logger.log(`Running the seed() method for seeder :${seeder.constructor.name}`);
+  //   await seeder.seed();
+  //   return { message: `seed data for ${seedData.seeder}` };
+  // }
 
 }

package/src/controllers/user.controller.ts

@@ -11,7 +11,7 @@ import { ActiveUserData } from '../interfaces/active-user-data.interface';
 import { SolidRequestContextDecorator } from 'src/decorators/solid-request-context.decorator';
 import { SolidRequestContextDto } from 'src/dtos/solid-request-context.dto';
 
-@ApiTags('Solid')
+@ApiTags('Solid Core')
 @Controller('user') //FIXME: Change this to the model plural name 
 export class UserController {
   constructor(private readonly service: UserService) { }

package/src/controllers/view-metadata.controller.ts

@@ -9,7 +9,7 @@ import { SolidRequestContextDto } from 'src/dtos/solid-request-context.dto';
 import { ActiveUser } from 'src/decorators/active-user.decorator';
 import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
 
-@ApiTags('App')
+@ApiTags('App Builder')
 @Controller('view-metadata') //FIXME: Change this to the model plural name 
 export class ViewMetadataController {
   constructor(private readonly service: ViewMetadataService) { }

package/src/dtos/update-settings.dto.ts

@@ -1,7 +1,6 @@
-import { IsNotEmpty, IsObject } from 'class-validator';
+import { IsObject, IsOptional } from 'class-validator';
 
 export class UpdateSettingsDto {
-    @IsObject()
-    @IsNotEmpty()
+    @IsOptional()
     settings: Record<string, any>;
 } 

package/src/entities/common.entity.ts

@@ -1,5 +1,5 @@
-import { PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, DeleteDateColumn, Index, ManyToOne, JoinColumn } from "typeorm"
-import { Locale } from "./locale.entity";
+import { Column, CreateDateColumn, DeleteDateColumn, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from "typeorm";
+import type { User } from "./user.entity";
 
 export abstract class CommonEntity {
     @PrimaryGeneratedColumn({ type: 'integer' })
@@ -25,4 +25,10 @@ export abstract class CommonEntity {
 
     @Column({ type: "int", name: 'default_entity_locale_id', default: null })
     defaultEntityLocaleId: number;
+
+    @ManyToOne(() => require('./user.entity').User?.default ?? require('./user.entity').User, { nullable: true })
+    createdBy: User;
+
+    @ManyToOne(() => require('./user.entity').User?.default ?? require('./user.entity').User, { nullable: true })
+    updatedBy: User;    
 }

package/src/entities/menu-item-metadata.entity.ts

@@ -23,7 +23,7 @@ export class MenuItemMetadata extends CommonEntity {
     @ManyToOne(() => ActionMetadata, { onDelete: "CASCADE", nullable: true })
     @JoinColumn({ referencedColumnName: 'id' })
     action: ActionMetadata;
-    @ManyToMany(() => RoleMetadata, roleMetadata => roleMetadata.users, { cascade: true })
+    @ManyToMany(() => RoleMetadata, roleMetadata => roleMetadata.menuItems, { cascade: true })
     @JoinTable()
     roles: RoleMetadata[];
     @Column({ name: "sequence_number", type: "int", nullable: true })

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

@@ -9,6 +9,7 @@ export interface PasswordFieldOptions {
     required: boolean | undefined | null;
     regexPattern: string | undefined | null;
     fieldName: string | undefined | null;
+    isUpdate: Boolean;
 }
 
 export class PasswordFieldCrudManager implements FieldCrudManager {
@@ -24,7 +25,10 @@ export class PasswordFieldCrudManager implements FieldCrudManager {
 
     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 (!this.options?.isUpdate && this.isApplyRequiredValidation() && isEmpty(fieldValue)) {
+            errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` });
+        }
+        // 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));
         }

package/src/helpers/model-metadata-helper.service.ts

@@ -0,0 +1,109 @@
+// Return the system fields metadata for a model
+
+import { Injectable, Logger } from "@nestjs/common";
+import { SolidRegistry } from "./solid-registry";
+import { In } from "typeorm";
+
+@Injectable()
+export class ModelMetadataHelperService {
+    private readonly logger = new Logger(ModelMetadataHelperService.name);
+
+    constructor(private readonly registry: SolidRegistry) {
+    }
+
+    getSystemFieldsMetadata(): any[] {
+        const systemFieldsMetadata = [
+            {
+                name: "id",
+                displayName: "Id",
+                type: "int",
+                ormType: "bigint",
+                isSystem: true,
+            },
+            {
+                name: "createdAt",
+                displayName: "Created At",
+                type: "datetime",
+                ormType: "timestamp",
+                isSystem: true,
+            },
+            {
+                name: "updatedAt",
+                displayName: "Updated At",
+                type: "datetime",
+                ormType: "timestamp",
+                isSystem: true,
+            },
+            {
+                name: "deletedAt",
+                displayName: "Deleted At",
+                type: "datetime",
+                ormType: "timestamp",
+                isSystem: true,
+            },
+            {
+                name: "deletedTracker",
+                displayName: "Deleted Tracker",
+                type: "shortText",
+                ormType: "varchar",
+                isSystem: true,
+            },
+            {
+                name: "publishedAt",
+                displayName: "Published At",
+                type: "datetime",
+                ormType: "timestamp",
+                isSystem: true,
+            },
+            {
+                name: "localeName",
+                displayName: "Locale",
+                type: "shortText",
+                ormType: "varchar",
+                isSystem: true,
+            },
+            {
+                name: "defaultEntityLocaleId",
+                displayName: "Default Entity Locale Id",
+                type: "int",
+                ormType: "integer",
+                isSystem: true,
+            },
+            {
+                name: "createdBy",
+                displayName: "Created By",
+                type: "relation",
+                ormType: "int",
+                isSystem: true,
+                relationType: "many-to-one",
+                relationCoModelSingularName: "user",
+                relationCreateInverse: false,
+                relationCascade: "restrict",
+                relationModelModuleName: "solid-core"
+            },
+            {
+                name: "updatedBy",
+                displayName: "Updated By",
+                type: "relation",
+                ormType: "int",
+                isSystem: true,
+                relationType: "many-to-one",
+                relationCoModelSingularName: "user",
+                relationCreateInverse: false,
+                relationCascade: "restrict",
+                relationModelModuleName: "solid-core"
+            },
+        ]
+
+        // Do an additional check and add a warning if the common entity keys and system field metadata keys don't match exactly
+        const commonEntityKeys = this.registry.getCommonEntityKeys();
+        const systemFieldNames = systemFieldsMetadata.map(field => field.name);
+        const missingKeys = commonEntityKeys.filter(key => !systemFieldNames.includes(key));
+        if (missingKeys.length > 0) {
+            this.logger.warn(`Missing system fields metadata for common entity keys: ${missingKeys.join(', ')}`);
+        }
+        return systemFieldsMetadata;
+    }
+
+
+}

package/src/helpers/schematic.service.ts

@@ -1,6 +1,8 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { CommandService } from './command.service';
 import { snakeCase } from "lodash";
+import { CommonEntity } from 'src/entities/common.entity';
+import { SolidRegistry } from './solid-registry';
 
 export const ADD_MODULE_COMMAND = 'add-module';
 export type GenerateModuleOptions = {
@@ -14,25 +16,19 @@ type FieldOptions = {
   dataSource: string;
   fields: any[]; //FIXME This type can be improved
   modelEnableSoftDelete?: boolean;
-  parentModel?: string;
+  parentModel?: string; 
   parentModule?: string;
+  draftPublishWorkflowEnabled?: boolean;
 };
 export const REMOVE_FIELDS_COMMAND = 'remove-fields';
 export const REFRESH_MODEL_COMMAND = 'refresh-model';
 
-enum SYSTEM_FIELDS_TO_IGNORE_FOR_CODE_GENERATION {
-  ID = 'id',
-  CREATED_AT = 'createdAt',
-  UPDATED_AT = 'updatedAt',
-  DELETED_AT = 'deletedAt'
-}
-
 //TODO Rename to CodeBuilder service
 @Injectable()
 export class SchematicService {
   private readonly logger = new Logger(SchematicService.name);
   private readonly SCHEMATIC_PROJECT = '@solidstarters/solid-code-builder';
-  constructor(private readonly commandService: CommandService) { }
+  constructor(private readonly commandService: CommandService, private readonly solidRegistry: SolidRegistry) { }
 
   async executeSchematicCommand(
     command: string,
@@ -79,9 +75,13 @@ export class SchematicService {
         modelCommand += ` --parent-module=${fieldOptions.parentModule}`;
       }
 
+      if (fieldOptions.draftPublishWorkflowEnabled) {
+        modelCommand += ` --draft-publish-workflow-enabled=${fieldOptions.draftPublishWorkflowEnabled}`;
+      }
+      
       let fieldCommand = fieldOptions.fields
         .filter((field) => {
-          return !Object.values(SYSTEM_FIELDS_TO_IGNORE_FOR_CODE_GENERATION).includes(field.name);
+          return !this.solidRegistry.getCommonEntityKeys().includes(field.name);
         })
         .map((field) => {
           return `--fields='${JSON.stringify(field)}'`;
@@ -101,5 +101,4 @@ export class SchematicService {
       throw new Error('Schematic command not supported.');
     }
   }
-
 }

package/src/helpers/solid-registry.ts

@@ -1,8 +1,9 @@
 import { Injectable } from '@nestjs/common';
 import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
-import { ISelectionProvider, ISelectionProviderContext } from "../interfaces";
+import { CommonEntity } from 'src/entities/common.entity';
 import { SecurityRule } from 'src/entities/security-rule.entity';
 import { EntityManager } from 'typeorm';
+import { ISelectionProvider, ISelectionProviderContext } from "../interfaces";
 import { Locale } from 'src/entities/locale.entity';
 
 type ControllerMetadata = {
@@ -147,4 +148,8 @@ export class SolidRegistry {
     return entityMetadata.target;
   }
 
+  getCommonEntityKeys(): (keyof CommonEntity) [] {
+        return Reflect.getMetadataKeys(CommonEntity.prototype) as (keyof CommonEntity)[];
+  }
+
 }

package/src/index.ts

@@ -242,7 +242,7 @@ export * from './repository/field.repository'
 
 //softDeleteAwareEventSubscriber.subscriber.ts
 export * from './subscribers/model.subscriber'
-export * from './subscribers/softDeleteAwareEventSubscriber.subscriber' //rename
+export * from './subscribers/soft-delete-aware-event.subscriber' //rename
 export * from './subscribers/view-metadata.subscriber' //rename
 export * from './subscribers/audit.subscriber'
 
@@ -259,4 +259,4 @@ export * from './interfaces'
 export * from './solid-core.module'
 
 export * from './winston.logger'
-export * from './transformers/datetime-transformer'
+export { default as datetimeTransformer } from './transformers/datetime-transformer'

package/src/interfaces.ts

@@ -43,9 +43,9 @@ export interface ModuleMetadataConfiguration {
     moduleMetadata?: CreateModuleMetadataDto,
     roles?: CreateRoleMetadataDto[],
     users?: SignUpDto[],
-    actions?: CreateActionMetadataDto[],
-    menus?: CreateMenuItemMetadataDto[],
-    views?: CreateViewMetadataDto[],
+    actions?: any[],
+    menus?: any[],
+    views?: any[],
     emailTemplates?: CreateEmailTemplateDto[],
     smsTemplates?: CreateSmsTemplateDto[],
     mediaStorageProviders?: CreateMediaStorageProviderMetadataDto[]

package/src/seeders/module-metadata-seeder.service.ts

@@ -409,8 +409,10 @@ export class ModuleMetadataSeederService {
             viewData['model'] = await this.modelMetadataService.findOneByUserKey(viewData.modelUserKey);
             // await this.solidViewService.upsert(viewData);
             // First check if module already exists using name
-            await this.solidViewService.createIfNotPresent(viewData);
 
+            // Changed the below to upsert as now we are saving modifications to the view json to file system also.
+            // await this.solidViewService.createIfNotPresent(viewData);
+            await this.solidViewService.upsert(viewData);
         }
     }
 

package/src/seeders/system-fields-seeder.service.ts

@@ -0,0 +1,53 @@
+// This class will add the system fields in the field-metadata table if they are missing.
+// Fetch all the models and their fields metadata and check if the system fields are present.
+
+import { InjectRepository } from "@nestjs/typeorm";
+import { ModelMetadata } from "src/entities/model-metadata.entity";
+import { ModelMetadataHelperService } from "src/helpers/model-metadata-helper.service";
+import { FieldRepository } from "src/repository/field.repository";
+import { Repository } from "typeorm";
+
+export class SystemFieldsSeederService {
+   // This service is responsible for seeding the system fields metadata for all models.
+   // It will check if the system fields are already present in the field-metadata table.
+   // If not, it will add them.
+   constructor(
+      private readonly modelHelperService: ModelMetadataHelperService,
+      @InjectRepository(ModelMetadata)
+      private readonly modelRepository: Repository<ModelMetadata>, // Replace with actual model repository type
+      @InjectRepository(FieldRepository)
+      private readonly fieldRepository: Repository<FieldRepository>, // Replace with actual field repository type
+   ) {}
+  
+   async seed() {
+     // Get the model repo
+     const models = await this.modelRepository.find({
+       relations: ['fields'], // Assuming 'fields' is the relation to field metadata
+     });
+
+     for (const model of models) {
+         // Check if the system fields are already present
+         await this.seedMissingSystemFields(model);
+      }
+   }
+
+    private async seedMissingSystemFields(model: ModelMetadata) {
+        const existingSystemFields = model.fields.filter(field => field.isSystem);
+        const systemFieldsMetadata = this.modelHelperService.getSystemFieldsMetadata();
+
+        // Find out which system fields are missing
+        const missingFields = systemFieldsMetadata.filter(
+            sysField => !existingSystemFields.some(field => field.name === sysField.name)
+        );
+
+        // If there are missing fields, add them
+        if (missingFields.length > 0) {
+            const newFields = missingFields.map(field => ({
+                ...field,
+                model: model, // Associate the field with the current model
+            }));
+            await this.fieldRepository.save(newFields);
+        }
+    }
+}
+   

package/src/services/authentication.service.ts

@@ -362,7 +362,7 @@ export class AuthenticationService {
                     solidAppName: process.env.SOLID_APP_NAME,
                     solidAppWebsiteUrl: process.env.SOLID_APP_WEBSITE_URL,
                     firstName: user.username,
-                    fullName: user.fullName,
+                    fullName: user.fullName ? user.fullName : user.username,
                     emailVerificationTokenOnRegistration: user.emailVerificationTokenOnRegistration,
                 },
                 this.commonConfiguration.shouldQueueEmails,
@@ -379,7 +379,7 @@ export class AuthenticationService {
                     otp: user.mobileVerificationTokenOnRegistration,
                     mobileVerificationTokenOnRegistration: user.mobileVerificationTokenOnRegistration,
                     firstName: user.username,
-                    fullName: user.fullName,
+                    fullName: user.fullName ? user.fullName : user.username,
                 }
             );
         }
@@ -544,7 +544,7 @@ export class AuthenticationService {
                     solidAppWebsiteUrl: process.env.SOLID_APP_WEBSITE_URL,
                     firstName: user.username,
                     emailVerificationTokenOnLogin: user.emailVerificationTokenOnLogin,
-                    fullName: user.fullName,
+                    fullName: user.fullName ? user.fullName : user.username,
                 },
                 this.commonConfiguration.shouldQueueEmails,
                 'user',
@@ -560,7 +560,7 @@ export class AuthenticationService {
                     otp: user.mobileVerificationTokenOnLogin,
                     mobileVerificationTokenOnLogin: user.mobileVerificationTokenOnLogin,
                     firstName: user.username,
-                    fullName: user.fullName,
+                    fullName: user.fullName ? user.fullName : user.username,
                 }
             );
         }

package/src/services/computed-fields/concat-computed-field-provider.service.ts

@@ -25,6 +25,9 @@ export class ConcatComputedFieldProvider implements IComputedFieldProvider<any>
         const fields = ctxt.fields;
         const slugify = ctxt.slugify || false;
 
+        if (!Array.isArray(fields) || fields?.length === 0) {
+            return '';
+        }
         let concatenatedString = '';
         for (let i = 0; i < fields.length; i++) {
             const field = fields[i];

package/src/services/crud.service.ts

@@ -109,8 +109,8 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         });
     }
 
-    private async validateAndTransformDto(field: FieldMetadata, dto: any, files: Express.Multer.File[], hasMediaFields: boolean, isPartialUpdate: boolean = false) {
-        const fieldManager: FieldCrudManager = this.fieldCrudManager(field, this.entityManager, isPartialUpdate);
+    private async validateAndTransformDto(field: FieldMetadata, dto: any, files: Express.Multer.File[], hasMediaFields: boolean, isPartialUpdate: boolean = false, isUpdate: boolean = false) {
+        const fieldManager: FieldCrudManager = this.fieldCrudManager(field, this.entityManager, isPartialUpdate, isUpdate);
         const validationErrors = fieldManager.validate(dto, files);
         const errors = (validationErrors instanceof Promise) ? await validationErrors : validationErrors;
         if (errors.length > 0) {
@@ -150,10 +150,11 @@ 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 = {}): Promise<T> {
+    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');
         }
+        isUpdate = true;
         const model = await this.loadModel();
         // Check wheather user has update permission for model
         if (solidRequestContext.activeUser) {
@@ -185,7 +186,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         // 2. Loop through the fields with a switch statement
         // 3. Handle the fields based on field type
         for (const field of fieldsToProcess) {
-            const transformed = await this.validateAndTransformDto(field, updateDto, files, hasMediaFields, isPartialUpdate);
+            const transformed = await this.validateAndTransformDto(field, updateDto, files, hasMediaFields, isPartialUpdate, isUpdate);
             updateDto = transformed.dto;
             hasMediaFields = transformed.hasMediaFields;
         }
@@ -257,8 +258,8 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         }
     }
 
-    private fieldCrudManager(fieldMetadata: FieldMetadata, entityManager: EntityManager, isPartialUpdate: boolean = false): FieldCrudManager {
-        const commonOptions = { required: fieldMetadata.required && !isPartialUpdate, fieldName: fieldMetadata.name };
+    private fieldCrudManager(fieldMetadata: FieldMetadata, entityManager: EntityManager, isPartialUpdate: boolean = false, isUpdate: boolean = false): FieldCrudManager {
+        const commonOptions = { required: fieldMetadata.required && !isPartialUpdate, fieldName: fieldMetadata.name, isUpdate};
         switch (fieldMetadata.type) {
             case SolidFieldType.shortText: {
                 const options = { ...commonOptions, length: fieldMetadata.max, regexPattern: fieldMetadata.regexPattern };