@solidstarters/solid-core 1.2.193 → 1.2.201

package/src/entities/model-sequence.entity.ts

@@ -0,0 +1,32 @@
+import { CommonEntity } from "src/entities/common.entity"
+import { Entity, JoinColumn, ManyToOne, Index, Column } from 'typeorm';
+import { ModuleMetadata } from 'src/entities/module-metadata.entity';
+import { ModelMetadata } from 'src/entities/model-metadata.entity';
+import { FieldMetadata } from 'src/entities/field-metadata.entity'
+
+@Entity('ss_model_sequence')
+export class ModelSequence extends CommonEntity {
+    @Index()
+    @ManyToOne(() => ModuleMetadata, { nullable: false })
+    @JoinColumn()
+    module: ModuleMetadata;
+    @Index()
+    @ManyToOne(() => ModelMetadata, { nullable: false })
+    @JoinColumn()
+    model: ModelMetadata;
+    @Index()
+    @ManyToOne(() => FieldMetadata, { nullable: false })
+    @JoinColumn()
+    field: FieldMetadata;
+    @Index({ unique: true })
+    @Column({ type: "varchar" })
+    sequenceName: string;
+    @Column({ type: "integer", default: 1 })
+    currentValue: number;
+    @Column({ type: "varchar", nullable: true })
+    prefix: string;
+    @Column({ type: "integer", default: 5 })
+    padding: number;
+    @Column({ type: "varchar", default: "" })
+    separator: string;
+}

package/src/entities/mq-message-queue.entity.ts

@@ -6,7 +6,7 @@ export class MqMessageQueue extends CommonEntity{
 @Column({ type: "varchar", unique: true })
 name: string;
 
-@Column({ type: "varchar", unique: true, nullable: true })
+@Column({ type: "varchar", nullable: true })
 description: string;
 
 @OneToMany(() => MqMessage, mqMessage => mqMessage.mqMessageQueue, { cascade: true })

package/src/entities/mq-message.entity.ts

@@ -1,52 +1,52 @@
 import { CommonEntity } from "src/entities/common.entity"
-import {Entity, Column, Index, ManyToOne} from "typeorm";
+import { Entity, Column, Index, ManyToOne } from "typeorm";
 import { MqMessageQueue } from 'src/entities/mq-message-queue.entity'
 @Entity("ss_mq_message")
-export class MqMessage extends CommonEntity{
-@Column({ type: "varchar", nullable: true })
-messageId: string;
+export class MqMessage extends CommonEntity {
+    @Column({ type: "varchar", nullable: true })
+    messageId: string;
 
-@Column({ type: "varchar", nullable: true })
-messageBroker: string;
+    @Column({ type: "varchar", nullable: true })
+    messageBroker: string;
 
-@Column({ type: "integer", nullable: true })
-retryCount: number;
+    @Column({ type: "integer", nullable: true })
+    retryCount: number;
 
-@Column({ type: "integer", nullable: true })
-retryInterval: number;
+    @Column({ type: "integer", nullable: true })
+    retryInterval: number;
 
-@Column({ type: "varchar", nullable: true })
-messageType: string;
+    @Column({ type: "varchar", nullable: true })
+    messageType: string;
 
-@Index()
-@Column({ type: "varchar" })
-stage: string;
+    @Index()
+    @Column({ type: "varchar" })
+    stage: string;
 
-@Column({ type: "timestamp", nullable: true })
-startedAt: Date;
+    @Column({ nullable: true })
+    startedAt: Date;
 
-@Column({ type: "timestamp", nullable: true })
-finishedAt: Date;
+    @Column({ nullable: true })
+    finishedAt: Date;
 
-@Column({ type: "integer", nullable: true })
-elapsedMillis: number;
+    @Column({ type: "integer", nullable: true })
+    elapsedMillis: number;
 
-@Column({ type: "varchar", nullable: true })
-input: any;
+    @Column({ type: "text", nullable: true })
+    input: string;
 
-@Column({ type: "varchar", nullable: true })
-output: any;
+    @Column({ type: "text", nullable: true })
+    output: string;
 
-@Column({ type: "varchar", nullable: true })
-error: any;
+    @Column({ type: "text", nullable: true })
+    error: string;
 
-@Column({ type: "integer", nullable: true })
-parentEntityId: number;
+    @Column({ type: "integer", nullable: true })
+    parentEntityId: number;
 
-@Column({ type: "varchar", nullable: true })
-parentEntity: string;
+    @Column({ type: "varchar", nullable: true })
+    parentEntity: string;
 
-@Index()
-@ManyToOne(() => MqMessageQueue, { onDelete: "CASCADE" })
-mqMessageQueue: MqMessageQueue;
+    @Index()
+    @ManyToOne(() => MqMessageQueue, {})
+    mqMessageQueue: MqMessageQueue;
 }

package/src/entities/saved-filters.entity.ts

@@ -1,5 +1,5 @@
 import { CommonEntity } from 'src/entities/common.entity'
-import {Entity, Column, JoinColumn, ManyToOne} from 'typeorm';
+import { Entity, Column, JoinColumn, ManyToOne } from 'typeorm';
 import { User } from 'src/entities/user.entity';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { ViewMetadata } from 'src/entities/view-metadata.entity'
@@ -10,15 +10,15 @@ export class SavedFilters extends CommonEntity {
     filterQueryJson: any;
     @Column({ type: "varchar" })
     name: string;
-    @Column({ type: "boolean", nullable: true, default: false })
+    @Column({ nullable: true, default: false })
     isPrivate: boolean = false;
-    @ManyToOne(() => User, { onDelete: "CASCADE", nullable: true })
+    @ManyToOne(() => User, { nullable: true })
     @JoinColumn()
     user: User;
-    @ManyToOne(() => ModelMetadata, { onDelete: "RESTRICT", nullable: false })
+    @ManyToOne(() => ModelMetadata, { nullable: false })
     @JoinColumn()
     model: ModelMetadata;
-    @ManyToOne(() => ViewMetadata, { onDelete: "RESTRICT", nullable: false })
+    @ManyToOne(() => ViewMetadata, { nullable: false })
     @JoinColumn()
     view: ViewMetadata;
     @Column({ name: "description", type: "text", nullable: true })

package/src/entities/scheduled-job.entity.ts

@@ -7,7 +7,7 @@ export class ScheduledJob extends CommonEntity {
     @Index({ unique: true })
     @Column({ type: "varchar" })
     scheduleName: string;
-    @Column({ type: "boolean", default: false })
+    @Column({ default: false })
     isActive: boolean = false;
     @Column({ type: "varchar" })
     frequency: string;
@@ -21,16 +21,16 @@ export class ScheduledJob extends CommonEntity {
     endDate: Date;
     @Column({ type: "integer", nullable: true })
     dayOfMonth: number;
-    @Column({ type: "timestamp", nullable: true })
+    @Column({ nullable: true })
     lastRunAt: Date;
-    @Column({ type: "timestamp", nullable: true })
+    @Column({ nullable: true })
     nextRunAt: Date;
     @Column({ type: "varchar", nullable: true })
     dayOfWeek: string;
     @Column({ type: "varchar" })
     job: string;
     @Index()
-    @ManyToOne(() => ModuleMetadata, { onDelete: "CASCADE", nullable: false })
+    @ManyToOne(() => ModuleMetadata, { nullable: false })
     @JoinColumn({ referencedColumnName: 'id' })
     module: ModuleMetadata;
 }

package/src/entities/security-rule.entity.ts

@@ -12,11 +12,11 @@ export class SecurityRule extends CommonEntity {
     @Column({ type: "varchar" })
     description: string;
     @Index()
-    @ManyToOne(() => RoleMetadata, { onDelete: "CASCADE", nullable: false })
+    @ManyToOne(() => RoleMetadata, { nullable: false })
     @JoinColumn()
     role: RoleMetadata;
     @Index()
-    @ManyToOne(() => ModelMetadata, { onDelete: "CASCADE", nullable: false })
+    @ManyToOne(() => ModelMetadata, { nullable: false })
     @JoinColumn()
     modelMetadata: ModelMetadata;
     @Column({ type: "text" })

package/src/entities/setting.entity.ts

@@ -5,13 +5,13 @@ import { User } from 'src/entities/user.entity'
 @Entity("ss_setting")
 export class Setting extends CommonEntity {
     @Index({ unique: true })
-    @Column({ type: "varchar", nullable: true })
+    @Column({ type: "varchar", nullable: false })
     key: string;
     @Column({ type: "varchar", nullable: true })
     value: string;
     @Column({ name: "type", type: "varchar", nullable: true })
     type: string;
-    @ManyToOne(() => User, { onDelete: "CASCADE", nullable: true })
+    @ManyToOne(() => User, { nullable: true })
     @JoinColumn()
     user: User;
 }

package/src/entities/sms-template.entity.ts

@@ -4,7 +4,7 @@ import { Column, Entity, Index } from 'typeorm';
 @Entity("ss_sms_template")
 export class SmsTemplate extends CommonEntity {
     @Index({ unique: true })
-    @Column({ name: "name", type: "varchar", unique: true })
+    @Column({ name: "name", type: "varchar"})
     name: string;
     @Column({ name: "display_name", type: "varchar" })
     displayName: string;
@@ -14,7 +14,7 @@ export class SmsTemplate extends CommonEntity {
     smsProviderTemplateId: string;
     @Column({ name: "description", type: "text", nullable: true })
     description: string;
-    @Column({ name: "active", type: "boolean", nullable: true, default: true })
+    @Column({ name: "active", nullable: true, default: true })
     active: boolean = true;
     @Column({ name: "type", type: "varchar", nullable: true })
     type: string;

package/src/entities/user-activity-history.entity.ts

@@ -1,21 +1,21 @@
 import { CommonEntity } from 'src/entities/common.entity'
-import {Entity, JoinColumn, ManyToOne, Column, Index} from 'typeorm';
+import { Entity, JoinColumn, ManyToOne, Column, Index } from 'typeorm';
 import { User } from 'src/entities/user.entity'
 @Entity("ss_user_activity_history")
-export class UserActivityHistory extends CommonEntity{
-@ManyToOne(() => User, { onDelete: "CASCADE", nullable: true })
-@JoinColumn()
-user: User;
+export class UserActivityHistory extends CommonEntity {
+    @ManyToOne(() => User, { nullable: true })
+    @JoinColumn()
+    user: User;
 
-@Index()
-@Column({ type: "varchar", nullable: true })
-event: string;
+    @Index()
+    @Column({ type: "varchar", nullable: true })
+    event: string;
 
-@Index()
-@Column({ type: "varchar", nullable: true })
-ipAddress: string;
+    @Index()
+    @Column({ type: "varchar", nullable: true })
+    ipAddress: string;
 
-@Index()
-@Column({ type: "varchar", nullable: true })
-userAgent: string;
+    @Index()
+    @Column({ type: "varchar", nullable: true })
+    userAgent: string;
 }

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

@@ -6,13 +6,13 @@ import { User } from 'src/entities/user.entity'
 @Entity("ss_user_view_metadata")
 export class UserViewMetadata extends CommonEntity {
     @Index()
-    @ManyToOne(() => User, { onDelete: "CASCADE", nullable: false })
+    @ManyToOne(() => User, { nullable: false })
     @JoinColumn()
     user: User;
     @Column({ name: "layout", type: "text", nullable: true })
     layout: any = "{}";
     @Index()
-    @ManyToOne(() => ViewMetadata, { onDelete: "CASCADE", nullable: false })
+    @ManyToOne(() => ViewMetadata, { nullable: false })
     @JoinColumn()
     viewMetadata: ViewMetadata;
 }

package/src/entities/user.entity.ts

@@ -15,18 +15,18 @@ export class User extends CommonEntity {
     @Column({ type: "varchar" })
     @Expose()
     username: string;
-    @Index({ unique: true })
+    // @Index({ unique: true })
     @Column({ type: "varchar", nullable: true })
     @Expose()
     email: string;
-    @Index({ unique: true })
+    // @Index({ unique: true })
     @Column({ type: "varchar", nullable: true })
     @Expose()
     mobile: string;
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     password: string;
-    @Column({ type: "boolean", nullable: true, default: true })
+    @Column({ nullable: true, default: true })
     @Expose()
     forcePasswordChange: boolean = true;
     @Column({ type: "varchar", default: "local" })
@@ -44,52 +44,52 @@ export class User extends CommonEntity {
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     googleProfilePicture: string;
-    @Column({ type: "boolean", default: true })
+    @Column({ default: true })
     @Expose()
     active: boolean = true;
-    @Column({ type: "timestamp", nullable: true })
+    @Column({ nullable: true })
     // don't send to client
     forgotPasswordConfirmedAt: Date;
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     verificationTokenOnForgotPassword: string;
-    @Column({ type: "timestamp", nullable: true })
+    @Column({ nullable: true })
     // don't send to client
     verificationTokenOnForgotPasswordExpiresAt: Date;
-    @Column({ type: "timestamp", nullable: true })
+    @Column({ nullable: true })
     // don't send to client
     emailVerifiedOnRegistrationAt: Date;
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     emailVerificationTokenOnRegistration: string;
-    @Column({ type: "timestamp", nullable: true })
+    @Column({ nullable: true })
     // don't send to client
     emailVerificationTokenOnRegistrationExpiresAt: Date;
-    @Column({ type: "timestamp", nullable: true })
+    @Column({ nullable: true })
     // don't send to client
     mobileVerifiedOnRegistrationAt: Date;
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     mobileVerificationTokenOnRegistration: string;
-    @Column({ type: "timestamp", nullable: true })
+    @Column({ nullable: true })
     // don't send to client
     mobileVerificationTokenOnRegistrationExpiresAt: Date;
-    @Column({ type: "timestamp", nullable: true })
+    @Column({ nullable: true })
     // don't send to client
     emailVerifiedOnLoginAt: Date;
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     emailVerificationTokenOnLogin: string;
-    @Column({ type: "timestamp", nullable: true })
+    @Column({ nullable: true })
     // don't send to client
     emailVerificationTokenOnLoginExpiresAt: Date;
-    @Column({ type: "timestamp", nullable: true })
+    @Column({ nullable: true })
     // don't send to client
     mobileVerifiedOnLoginAt: Date;
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     mobileVerificationTokenOnLogin: string;
-    @Column({ type: "timestamp", nullable: true })
+    @Column({ nullable: true })
     // don't send to client
     mobileVerificationTokenOnLoginExpiresAt: Date;
     @Column({ type: "varchar", nullable: true })
@@ -109,7 +109,7 @@ export class User extends CommonEntity {
     @Column({ type: "int", default: 1 })
     passwordSchemeVersion: number;
     // dont send to client
-    @Column({ type: "timestamp", nullable: true })
+    @Column({ nullable: true })
     rehashedAt: Date;
     @Expose()
     _media: any;

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

@@ -7,7 +7,7 @@ import { UserViewMetadata } from 'src/entities/user-view-metadata.entity'
 @Entity("ss_view_metadata")
 export class ViewMetadata extends CommonEntity {
     @Index({ unique: true })
-    @Column({ name: "name", type: "varchar", unique: true })
+    @Column({ name: "name", type: "varchar"})
     name: string;
     @Column({ name: "display_name", type: "varchar" })
     displayName: string;
@@ -18,11 +18,11 @@ export class ViewMetadata extends CommonEntity {
     @Column({ name: "layout", type: "text" })
     layout: any;
     @Index()
-    @ManyToOne(() => ModuleMetadata, { onDelete: "CASCADE", nullable: false })
+    @ManyToOne(() => ModuleMetadata, { nullable: false })
     @JoinColumn({ referencedColumnName: 'id' })
     module: ModuleMetadata;
     @Index()
-    @ManyToOne(() => ModelMetadata, { onDelete: "CASCADE", nullable: false })
+    @ManyToOne(() => ModelMetadata, { nullable: false })
     @JoinColumn({ referencedColumnName: 'id' })
     model: ModelMetadata;
     @OneToMany(() => UserViewMetadata, userViewMetadata => userViewMetadata.viewMetadata, { cascade: true })

package/src/helpers/date.helper.ts

@@ -1,13 +1,34 @@
 import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+dayjs.extend(customParseFormat);
 
-
-export function parseFlexibleDate(value: string): Date | null {
-    if (!value) return null;
-    const formats = ['DD-MM-YYYY', 'YYYY-MM-DD'];
-    const parsed = dayjs(value, formats, true); // true = strict parsing
-    if (!parsed.isValid()) {
-      return null;
-    }
-    return parsed.toDate();
+export function parseFlexibleDate(value: any): Date | null {
+  if (!value) return null;
+  if (value instanceof Date && !isNaN(value.getTime())) {
+    return value;
+  }
+  if (typeof value === 'number') {
+    const excelEpoch = new Date(Date.UTC(1899, 11, 30));
+    const d = new Date(excelEpoch.getTime() + value * 86400000);
+    return isNaN(d.getTime()) ? null : d;
   }
-  
+  const str = value.toString().trim();
+  const formats = [
+    'DD-MM-YYYY',
+    'YYYY-MM-DD',
+    'DD/MM/YYYY',
+    'MM/DD/YYYY',
+    'D-M-YYYY',
+    'YYYY/MM/DD',
+    'YYYY-MM-DD HH:mm:ss',
+    'YYYY-MM-DDTHH:mm:ss',       // ISO without Z
+    'YYYY-MM-DDTHH:mm:ss.SSS',   // ISO with millis
+    'YYYY-MM-DDTHH:mm:ssZ',      // ISO with timezone
+  ];
+  const parsed = dayjs(str, formats, true); // true = strict parsing
+  if (!parsed.isValid()) {
+    return null;
+  }
+  return parsed.toDate();
+}
+

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

@@ -14,13 +14,22 @@ export class BigIntFieldCrudManager implements FieldCrudManager {
     }
 
     validate(createDto: any): ValidationError[] {
-        const fieldValue: any = createDto[this.options.fieldName];
+        let fieldValue: any = createDto[this.options.fieldName];
+        if (fieldValue !== undefined && fieldValue !== null) {
+            try {
+                if (typeof fieldValue === 'string' || typeof fieldValue === 'number') {
+                    fieldValue = BigInt(fieldValue);
+                }
+            } catch (err) {
+                return [{ field: this.options.fieldName, error: 'Invalid numeric value' }];
+            }
+        }
         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";
+        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));
         }
@@ -29,7 +38,7 @@ export class BigIntFieldCrudManager implements FieldCrudManager {
 
     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.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;
@@ -43,13 +52,17 @@ export class BigIntFieldCrudManager implements FieldCrudManager {
     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';
-      }
+        const valueType = typeof value;
+        return valueType === 'bigint' || (valueType === 'number' && Number.isFinite(value));
+    }
 }

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

@@ -68,11 +68,11 @@ export class ManyToManyRelationFieldCrudManager implements FieldCrudManager {
     }
 
     async transformForCreate(dto: any): Promise<any> {
-        const currentEntityTarget = this.getEntityTarget(classify(this.options.modelSingularName));
-        const currentEntityRepository = this.options.entityManager.getRepository(currentEntityTarget);
+        const currentEntityName = classify(this.options.modelSingularName);
+        const currentEntityRepository = this.options.entityManager.getRepository(currentEntityName);
 
-        const relatedEntityTarget = this.getEntityTarget(classify(this.options.relationCoModelSingularName));
-        const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityTarget)
+        const relatedEntityName = classify(this.options.relationCoModelSingularName);
+        const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityName)
 
         dto[this.valueFieldName] = await this.transformByCommand(dto, relatedEntityRepository, currentEntityRepository);
         return dto;
@@ -192,9 +192,9 @@ export class ManyToManyRelationFieldCrudManager implements FieldCrudManager {
 
     // TODO: We have moved this to SolidRegistry service, refactor to use that service.
     // 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;
-    }
+    // 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

@@ -1,4 +1,5 @@
 import { classify } from "@angular-devkit/core/src/utils/strings";
+import { BadRequestException } from "@nestjs/common";
 import { isEmpty, isNotEmpty, isString } from "class-validator";
 import { FieldCrudManager, ValidationError } from "src/interfaces";
 import { IsParsableInt } from "src/validators/is-parsable-int";
@@ -64,16 +65,23 @@ export class ManyToOneRelationFieldCrudManager implements FieldCrudManager {
         // Avoid transforming if both fieldId and fieldUserKey  is empty
         if ((isEmpty(fieldId)) && isEmpty(fieldUserKeyValue)) return dto;
 
+         if (!this.options.relationCoModelSingularName) {
+            throw new BadRequestException(`ManyToOneRelationFieldCrudManager: relationCoModelSingularName is not defined in the field: ${this.options.fieldName}`);
+        }
         // // Load the related entity from the database, using the repository of the related entity
-        const entityTarget = this.getRelatedEntityTarget(classify(this.options.relationCoModelSingularName));
+        //const entityTarget = this.getRelatedEntityTarget(classify(this.options.relationCoModelSingularName));
+        const coModelEntityName = classify(this.options.relationCoModelSingularName);
+
+        //Load the related entity from the database, using the repository of the related entity
+        //const entityTarget = this.getRelatedEntityTarget(classify(this.options.relationCoModelSingularName));
         if (isNotEmpty(fieldId)) {
-            dto[this.options.fieldName] = await this.options.entityManager.getRepository(entityTarget).findOneBy({ id: fieldId });
+            dto[this.options.fieldName] = await this.options.entityManager.getRepository(coModelEntityName).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.relationCoModelSingularName}`);
             }
         }
         else {
-            dto[this.options.fieldName] = await this.options.entityManager.getRepository(entityTarget).findOneBy({ [this.options.relationCoModelUserKeyFieldName]: fieldUserKeyValue });
+            dto[this.options.fieldName] = await this.options.entityManager.getRepository(coModelEntityName).findOneBy({ [this.options.relationCoModelUserKeyFieldName]: fieldUserKeyValue });
             if (this.options.required && isEmpty(dto[this.options.fieldName])) {
                 throw new Error(`ManyToOneRelationFieldCrudManager: Record with userKey: ${this.options.relationCoModelUserKeyFieldName}: ${fieldUserKeyValue} not found in ${this.options.relationCoModelSingularName}`);
             }
@@ -88,10 +96,10 @@ export class ManyToOneRelationFieldCrudManager implements FieldCrudManager {
     }
 
     // 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;
-    }
+    // 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/OneToManyRelationFieldCrudManager.ts

@@ -75,11 +75,11 @@ export class OneToManyRelationFieldCrudManager implements FieldCrudManager {
 
     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 currentEntityName = classify(this.options.modelSingularName);
+        const currentEntityRepository = this.options.entityManager.getRepository(currentEntityName);
 
-        const relatedEntityTarget = this.getEntityTarget(classify(this.options.relationCoModelSingularName));
-        const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityTarget)
+        const relatedEntityName = classify(this.options.relationCoModelSingularName);
+        const relatedEntityRepository = this.options.entityManager.getRepository(relatedEntityName);
 
         dto[this.valueFieldName] = await this.transformByCommand(dto, relatedEntityRepository, currentEntityRepository);
         return dto;
@@ -197,9 +197,9 @@ export class OneToManyRelationFieldCrudManager implements FieldCrudManager {
 
     // TODO: We have moved this to SolidRegistry service, refactor to use that service.
     // 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;
-    }
+    // 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;
+    // }
 }