@solidstarters/solid-code-builder 1.0.12 → 1.0.14

package/src/code-builder/lib/field/FieldManager.ts

@@ -182,51 +182,51 @@ export function getFieldHandler(
   moduleName: string,
   modelName: string,
   field: any,
+  modelEnableSoftDelete: any,
 ): FieldHandler {
-  // console.log('field', field);
   switch (field.type) {
     case SolidFieldType.shortText:
     case SolidFieldType.selectionStatic:
     case SolidFieldType.selectionDynamic:
       if (field.selectionValueType === "int") {
-        return new IntFieldHandler(tree, moduleName, modelName, field);
+        return new IntFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
       }
-      return new ShortTextFieldHandler(tree, moduleName, modelName, field);
+      return new ShortTextFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
     case SolidFieldType.longtext:
-      return new LongTextFieldHandler(tree, moduleName, modelName, field);
+      return new LongTextFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
     case SolidFieldType.richText:
-      return new RichTextFieldHandler(tree, moduleName, modelName, field);
+      return new RichTextFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
     case SolidFieldType.json:
-      return new JsonFieldHandler(tree, moduleName, modelName, field);
+      return new JsonFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
     case SolidFieldType.int:
-      return new IntFieldHandler(tree, moduleName, modelName, field);
+      return new IntFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
     case SolidFieldType.decimal:
-      return new DecimalFieldHandler(tree, moduleName, modelName, field);
+      return new DecimalFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
     case SolidFieldType.bigint:
-      return new BigIntFieldHandler(tree, moduleName, modelName, field);  
+      return new BigIntFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);  
     case SolidFieldType.boolean:
-      return new BooleanFieldHandler(tree, moduleName, modelName, field);
+      return new BooleanFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
     case SolidFieldType.email:
-      return new EmailFieldHandler(tree, moduleName, modelName, field);
+      return new EmailFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
     case SolidFieldType.password:
-      return new PasswordFieldHandler(tree, moduleName, modelName, field);
+      return new PasswordFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
     case SolidFieldType.date:
     case SolidFieldType.datetime:
     case SolidFieldType.time:
-      return new DateFieldHandler(tree, moduleName, modelName, field);
+      return new DateFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
     case SolidFieldType.relation: {
       if (field.relationType === RelationType.ManyToOne) {
-        return new ManyToOneRelationFieldHandler(tree, moduleName, modelName, field);
+        return new ManyToOneRelationFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
       }
       else if (field.relationType === RelationType.OneToMany) {
-        return new OneToManyRelationFieldHandler(tree, moduleName, modelName, field);
+        return new OneToManyRelationFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
       }
       else if (field.relationType === RelationType.ManyToMany) {
         if (field.isRelationManyToManyOwner) {
-          return new ManyToManyRelationFieldHandler(tree, moduleName, modelName, field);
+          return new ManyToManyRelationFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
         }
         else {
-          return new ManyToManyInverseRelationFieldHandler(tree, moduleName, modelName, field);
+          return new ManyToManyInverseRelationFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
         }
       }
       return new NoOpsFieldHandler(tree, moduleName, modelName, field);
@@ -235,9 +235,9 @@ export function getFieldHandler(
     case SolidFieldType.mediaMultiple:
       return new NoOpsFieldHandler(tree, moduleName, modelName, field);
     case SolidFieldType.uuid:
-      return new UUIDFieldHandler(tree, moduleName, modelName, field);
+      return new UUIDFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
     case SolidFieldType.computed:
-      return new ComputedFieldHandler(tree, moduleName, modelName, field);
+      return new ComputedFieldHandler(tree, moduleName, modelName, field, modelEnableSoftDelete);
     default:
       console.log(`Field ${field.name} of type ${field.type} not supported yet`);
       return new NoOpsFieldHandler(tree, moduleName, modelName, field);
@@ -295,7 +295,7 @@ export class ManagerForDtoOptions {
     public sourceType: DtoSourceType,
   ) {}
 }
-// insertImport(this.source, this.source.fileName, `Update${classify(this.field.relationModelSingularName)}Dto`, relatedEntityPath);
+// insertImport(this.source, this.source.fileName, `Update${classify(this.field.relationCoModelSingularName)}Dto`, relatedEntityPath);
 export function safeInsertImport(source: ts.SourceFile, symbolName: string, importFileName: string, currentModuleName: string ): Change {
   // Check if in current source, there exists a class with the same symbolName
   if (importFileName.startsWith(`src/${SOLID_CORE_MODULE_NAME }`)) {

package/src/code-builder/lib/field/decorator-managers/entity/IndexDecoratorManager.ts

@@ -7,13 +7,13 @@ interface IndexDecoratorOptions {
     index: boolean;
     source: ts.SourceFile;
     field: any;
+    modelEnableSoftDelete?: any
 }
 
 export class IndexDecoratorManager implements DecoratorManager {
-
     constructor(public options: IndexDecoratorOptions, public fieldNode?: PropertyDeclaration) { }
     isApplyDecorator(): boolean {
-        return this.options.index && this.options.field.relationType !== RelationType.ManyToMany && this.options.field.relationType !== RelationType.OneToMany;
+        return (this.options.index || (!this.options.modelEnableSoftDelete && this.options.field.unique)) && this.options.field.relationType !== RelationType.ManyToMany && this.options.field.relationType !== RelationType.OneToMany;
     }
     decoratorName(): string {
         return 'Index';
@@ -25,7 +25,8 @@ export class IndexDecoratorManager implements DecoratorManager {
         const fieldSourceLines = [];
         const changes: Change[] = [];
         // if (this.field.index) {
-        const indexDecoratorLine = `@Index()`;
+        const indexOptions = this.buildColumnOptionsCode();
+        const indexDecoratorLine = indexOptions ? `@Index(${indexOptions})` : `@Index()`;
         fieldSourceLines.push(indexDecoratorLine);
         changes.push(...this.decoratorImports());
         // }
@@ -78,11 +79,23 @@ export class IndexDecoratorManager implements DecoratorManager {
     }
 
     private createIndexDecorator(): ts.ModifierLike {
+        const indexArguments: ts.Expression[] = [];
+        if ((this.options.modelEnableSoftDelete === undefined || this.options.modelEnableSoftDelete === false) 
+            && this.options.field.unique) {
+            indexArguments.push(
+                ts.factory.createObjectLiteralExpression([
+                    ts.factory.createPropertyAssignment(
+                        'unique',
+                        ts.factory.createTrue()
+                    )
+                ])
+            );
+        }
         return ts.factory.createDecorator(
             ts.factory.createCallExpression(
                 ts.factory.createIdentifier('Index'),
                 undefined,
-                [],
+                indexArguments
             ),
         );
     }
@@ -101,5 +114,36 @@ export class IndexDecoratorManager implements DecoratorManager {
         return identifier.text === identifierName;
     }
 
+    private buildColumnDecoratorOptions(): Map<string, any> { 
+        const options: Map<string, any> = new Map<string, any>();
+    
+        if ((this.options.modelEnableSoftDelete === undefined || this.options.modelEnableSoftDelete === false) 
+            && this.options.field.unique) {
+            options.set('unique', true);
+        }
+    
+        return options;
+    }
 
+    private buildColumnOptionsCode(): string {
+        const options = this.buildColumnDecoratorOptions();
+        const keys = Array.from(options.keys());
+    
+        if (keys.length === 0) {
+            return '';
+        }
+    
+        const optionsString = keys
+            .filter((key) => options.get(key) !== null)
+            .map((key) => {
+                if (typeof options.get(key) === 'string') {
+                    return `${key}: "${options.get(key)}"`;
+                } else {
+                    return `${key}: ${options.get(key)}`;
+                }
+            })
+            .join(', ');
+    
+        return `{ ${optionsString} }`;
+    }
 }

package/src/code-builder/lib/field/decorator-managers/entity/JoinColumnDecoratorManager.ts

@@ -8,7 +8,7 @@ interface JoinColumnDecoratorOptions {
     source: ts.SourceFile;
     field: any;
     fieldName: string;
-    relationModelFieldName?: string;
+    relationCoModelColumnName?: string;
 }
 
 export class JoinColumnDecoratorManager implements DecoratorManager {
@@ -88,8 +88,8 @@ export class JoinColumnDecoratorManager implements DecoratorManager {
     private buildRelationOptionsCode(): string {
         const options: Record<string, string> = {};
 
-        if (this.options.relationModelFieldName) {
-            options['name'] = `"${this.options.relationModelFieldName}_id"`;
+        if (this.options.relationCoModelColumnName) {
+            options['name'] = `"${this.options.relationCoModelColumnName}"`;
             return `{ ${Object.entries(options)
                 .map(([key, value]) => `${key}: ${value}`)
                 .join(', ')} }`;
@@ -102,11 +102,11 @@ export class JoinColumnDecoratorManager implements DecoratorManager {
 
         const newOptions: ts.ObjectLiteralElementLike[] = [];
 
-        if (this.options.relationModelFieldName) {
+        if (this.options.relationCoModelColumnName) {
             newOptions.push(
                 ts.factory.createPropertyAssignment(
                     'name',
-                    ts.factory.createStringLiteral(`${this.options.relationModelFieldName}_id`)
+                    ts.factory.createStringLiteral(`${this.options.relationCoModelColumnName}`)
                 )
             );
         }

package/src/code-builder/lib/field/decorator-managers/entity/ManyToOneDecoratorManager.ts

@@ -6,7 +6,7 @@ import { DecoratorManager, DeleteType, PartialAddFieldChange } from "../../Field
 import _ from 'lodash';
 interface ManyToOneDecoratorOptions {
     isManyToOne: boolean;
-    relationModelSingularName: string;
+    relationCoModelSingularName: string;
     relationCascade: DeleteType;
     required: boolean;
     source: ts.SourceFile;
@@ -37,7 +37,7 @@ export class ManyToOneDecoratorManager implements DecoratorManager {
         // }
         // Add the relation decorator
         fieldSourceLines.push(
-            `@${this.decoratorName()}(() => ${classify(this.options.relationModelSingularName)}, ${this.buildRelationOptionsCode()})`,
+            `@${this.decoratorName()}(() => ${classify(this.options.relationCoModelSingularName)}, ${this.buildRelationOptionsCode()})`,
         );
         changes.push(...this.decoratorImports());
         return {
@@ -148,7 +148,7 @@ export class ManyToOneDecoratorManager implements DecoratorManager {
             [],
             undefined,
             ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-            ts.factory.createIdentifier(classify(this.options.relationModelSingularName))
+            ts.factory.createIdentifier(classify(this.options.relationCoModelSingularName))
         )
         const decoratorOptionsExpression = ts.factory.createObjectLiteralExpression(newPropertyAssignments);
         const call = ts.factory.createCallExpression(decoratorIdentifier, undefined, [typeFunctionOrTarget, decoratorOptionsExpression]);

package/src/code-builder/lib/field/decorator-managers/entity/UniqueIndexDecoratorManager.ts

@@ -8,12 +8,13 @@ interface UniqueIndexDecoratorOptions {
     fieldName: string;
     source: ts.SourceFile;
     field: any;
+    modelEnableSoftDelete?: any;
 }
 
 export class UniqueIndexDecoratorManager {
     constructor(public options: UniqueIndexDecoratorOptions, public classNode: ClassDeclaration, public fieldNode?: PropertyDeclaration) { }
     isApplyDecorator(): boolean {
-        return this.options.unique;
+        return this.options.unique && this.options.modelEnableSoftDelete;
     }
     decoratorName(): string {
         return 'Index';
@@ -47,6 +48,7 @@ export class UniqueIndexDecoratorManager {
     // @returns the updated property declaration
     updateDecorator(): [ClassDeclaration, Change[]] {
         if (!this.classNode) throw new Error('Class node is required for updating the unique index decorator');
+        if (!this.fieldNode) throw new Error('Field node is required for updating the unique index decorator');
 
         let existingModifierLikes: ts.NodeArray<ModifierLike> | undefined = this.classNode.modifiers;
 

package/src/code-builder/lib/field/field-managers/base/BaseFieldManagerForDto.ts

@@ -1,6 +1,7 @@
 import { classify, dasherize } from '@angular-devkit/core/src/utils/strings';
 import { Tree } from '@angular-devkit/schematics';
 import ts, {
+  ClassDeclaration,
   PropertyDeclaration,
   SourceFile,
 } from '@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript';
@@ -48,6 +49,7 @@ import { ApiPropertyDecoratorManager } from '../../decorator-managers/dto/ApiPro
 // The validation decorators added use the class-validator library
 export abstract class BaseFieldManagerForDto implements FieldManager {
   source: SourceFile;
+  updatedSourceClassNode?: ts.ClassDeclaration;
   decoratorManagers: DecoratorManager[];
 
   constructor(
@@ -137,7 +139,7 @@ export abstract class BaseFieldManagerForDto implements FieldManager {
   protected addFieldInternal(fieldName: string, fieldType: string, decoratorManagers: DecoratorManager[], field: any, modelName: any, source: ts.SourceFile): FieldChange {
     //FIXME There might a case where the main field is not present, but additional field is present. Do we update the fields or throw an error. Needs to be discussed
     // For now, we assume, that if primary field is not present, then additional field is also not present
-    if (this.isFieldPresent(fieldName, source)) { 
+    if (this.isFieldPresent(fieldName, source)) {
       return {
         filePath: source.fileName,
         field: field,
@@ -166,14 +168,8 @@ export abstract class BaseFieldManagerForDto implements FieldManager {
       fieldSourceLines.push(...builderChange.fieldSourceLines);
     });
 
-    // Create the field definition changes
-    // const classNode = findNodes(source, ts.SyntaxKind.ClassDeclaration)[0];
-    const className = (this.options.sourceType === DtoSourceType.Create) ? `Create${classify(modelName)}Dto` : `Update${classify(modelName)}Dto`;
-    const classNode = getClassNode(className,source);
-    if (!classNode) {
-      throw new Error(`Class ${className} not found in file ${source.fileName}`);
-    }
-    
+    const classNode = this.getClassNode(modelName, this.options, source);
+
     const fieldDefinition = `\n${fieldSourceLines.reverse().join('\n')}\n`;
     changes.push(
       new InsertChange(
@@ -208,9 +204,9 @@ export abstract class BaseFieldManagerForDto implements FieldManager {
 
     const fieldName = this.fieldName();
     const fieldType = this.fieldType().text;
-    const source= this.source
+    const source = this.source
     const field = this.field
-    const modelName = this.modelName        
+    const modelName = this.modelName
     const decoratorManagers = this.decoratorManagers;
 
     fieldChanges.push(this.addFieldInternal(fieldName, fieldType, decoratorManagers, field, modelName, source));
@@ -241,7 +237,20 @@ export abstract class BaseFieldManagerForDto implements FieldManager {
     updatedPropertyDeclarationNode = updatedPropertyDeclarationNodeTransformed;
     changes.push(...decoratorChanges);
 
-    changes.push(...this.calculateReplaceChanges(this.printNode(updatedPropertyDeclarationNode, source), fieldPropertyDeclarationNode, source));
+    // changes.push(...this.calculateReplaceChanges(this.printNode(updatedPropertyDeclarationNode, source), fieldPropertyDeclarationNode, source));
+
+    // if (!this.isAdditionalFieldRequired()) {
+      // Get the source class node i.e CreateDto or UpdateDto
+      const sourceClassNode = this.getClassNode(this.modelName, this.options, source); // FIXME Avoid this.model to avoid stateful behaviour
+      const classNode = this.updatedSourceClassNode ?? sourceClassNode;
+      // Set the updated property declaration node to the source class node
+      const updatedClassNode = this.updateClassNode(classNode, updatedPropertyDeclarationNode, fieldName);
+      this.updatedSourceClassNode = updatedClassNode; // Set the updated class node to the source class node, so it can be used for additional operations e.g for additional field updates
+      changes.push(...this.calculateReplaceChanges(this.printNode(updatedClassNode, source), sourceClassNode, source.fileName)); 
+    // }
+    // else {
+    //   changes.push(...this.calculateReplaceChanges(this.printNode(updatedPropertyDeclarationNode, source), fieldPropertyDeclarationNode, source.fileName));
+    // }
 
     return {
       filePath: source.fileName,
@@ -250,6 +259,32 @@ export abstract class BaseFieldManagerForDto implements FieldManager {
     };
   }
 
+  updateClassNode(sourceClassNode: ts.ClassDeclaration, updatedFieldNode: ts.PropertyDeclaration, fieldName: string): ClassDeclaration {
+    // Replace the class memeber matching the field name with the updated field node
+    const newMembers = sourceClassNode.members.map((member) => {
+      // Check if the member is a PropertyDeclaration
+      if (ts.isPropertyDeclaration(member)) {
+        // Compare the name of the property with the field name
+        const memberName = member.name.getText();
+        if (memberName === fieldName) {
+          return updatedFieldNode!;
+        }
+      }
+      return member;
+    });
+
+    // Update the class node with the new modifiers
+    const updatedClass = ts.factory.updateClassDeclaration(
+      sourceClassNode,
+      sourceClassNode.modifiers,
+      sourceClassNode.name,
+      sourceClassNode.typeParameters,
+      sourceClassNode.heritageClauses,
+      newMembers,
+    );
+    return updatedClass;
+  }
+
   updateField(): FieldChange[] {
     const fieldChanges: FieldChange[] = [];
 
@@ -257,7 +292,7 @@ export abstract class BaseFieldManagerForDto implements FieldManager {
 
     const fieldName = this.fieldName();
     const fieldType = this.fieldType().node(this.field);
-    const source= this.source
+    const source = this.source
     const field = this.field
     const decoratorManagers = this.decoratorManagers;
 
@@ -365,7 +400,7 @@ export abstract class BaseFieldManagerForDto implements FieldManager {
         }
       }
     }
-  }  
+  }
 
   protected applyBuildDecoratorTransformations(...transformers: DecoratorManager[]): PartialAddFieldChange[] {
     const partialFieldChanges: PartialAddFieldChange[] = [];
@@ -385,24 +420,24 @@ export abstract class BaseFieldManagerForDto implements FieldManager {
     }
   }
 
-  protected calculateReplaceChanges(updatedPropertyDeclarationNodeText: string, fieldPropertyDeclarationNode: ts.PropertyDeclaration, source: ts.SourceFile): Change[] {
+  protected calculateReplaceChanges(updatedSourceNodeText: string, sourceNode:ts.Node, sourceFileName: string): Change[] {
     const changes: Change[] = [];
-    if (updatedPropertyDeclarationNodeText.trim() !==
-      fieldPropertyDeclarationNode.getFullText().trim()) {
-      console.log(`Updated Code:\n${updatedPropertyDeclarationNodeText.trim()}\nwith length ${updatedPropertyDeclarationNodeText.trim().length}\n`);
-      console.log(`Old Code:\n${fieldPropertyDeclarationNode.getFullText().trim()}\nwith length ${fieldPropertyDeclarationNode.getFullText().trim().length}\n`);
+    if (updatedSourceNodeText.trim() !==
+      sourceNode.getFullText().trim()) {
+      console.log(`Updated Code:\n${updatedSourceNodeText.trim()}\nwith length ${updatedSourceNodeText.trim().length}\n`);
+      console.log(`Old Code:\n${sourceNode.getFullText().trim()}\nwith length ${sourceNode.getFullText().trim().length}\n`);
       const replaceChange = new ReplaceChangeSSS(
-        source.fileName,
-        fieldPropertyDeclarationNode.pos,
-        fieldPropertyDeclarationNode.getFullText(),
-        `\n\n${updatedPropertyDeclarationNodeText}`
+        sourceFileName,
+        sourceNode.pos,
+        sourceNode.getFullText(),
+        `\n\n${updatedSourceNodeText}`
       );
       changes.push(replaceChange);
     }
     return changes;
   }
 
-  protected printNode(updatedPropertyDeclarationNode: ts.PropertyDeclaration, nodeSource: SourceFile): string {
+  protected printNode(updatedPropertyDeclarationNode: ts.Node, nodeSource: SourceFile): string {
     const printer = ts.createPrinter({
       newLine: ts.NewLineKind.LineFeed,
       removeComments: false,
@@ -432,7 +467,7 @@ export abstract class BaseFieldManagerForDto implements FieldManager {
         case DecoratorType.MinLength:
           return new MinLengthDecoratorManager({ isApplyMinLength: this.isApplyMinLength(), length: field.min, source: source, field: field });
         case DecoratorType.MaxLength:
-          return new MaxLengthDecoratorManager({ isApplyMaxLength: this.isApplyMaxLength(), length: field.max, source: source, field: field });  
+          return new MaxLengthDecoratorManager({ isApplyMaxLength: this.isApplyMaxLength(), length: field.max, source: source, field: field });
         case DecoratorType.Required:
           return new RequiredDecoratorManager({ isApplyRequired: true, required: field.required, source: source, field: field });
         case DecoratorType.Optional:
@@ -447,7 +482,7 @@ export abstract class BaseFieldManagerForDto implements FieldManager {
           return new IntDecoratorManager({ isInt: this.isInt(), source: source, field: field });
         case DecoratorType.Decimal:
           return new DecimalDecoratorManager({ isDecimal: this.isDecimal(), source: source, field: field });
-        case DecoratorType.BigInt:  
+        case DecoratorType.BigInt:
           return new BigIntDecoratorManager({ isBigInt: this.isBigInt(), source: source, field: field });
         case DecoratorType.Date:
           return new DateDecoratorManager({ isDate: this.isDate(), source: source, field: field });
@@ -482,4 +517,17 @@ export abstract class BaseFieldManagerForDto implements FieldManager {
     }
   }
 
+  private getClassNode(modelName: any, options: ManagerForDtoOptions, source: ts.SourceFile) {
+    // if (this.updatedSourceClassNode) {
+    //   return this.updatedSourceClassNode;
+    // }
+    const classifiedModelName = classify(modelName);
+    const sourceClassName = (options.sourceType === DtoSourceType.Create) ? `Create${classifiedModelName}Dto` : `Update${classifiedModelName}Dto`;
+    const classNode = getClassNode(sourceClassName, source);
+    if (!classNode) {
+      throw new Error(`Class ${sourceClassName} not found in file ${source.fileName}`);
+    }
+    return classNode;
+  }
+
 }

package/src/code-builder/lib/field/field-managers/base/BaseFieldManagerForEntity.ts

@@ -45,6 +45,7 @@ export abstract class BaseFieldManagerForEntity implements FieldManager {
     protected readonly moduleName: string,
     protected readonly modelName: string,
     protected readonly field: any,
+    protected readonly modelEnableSoftDelete?: any
   ) {
     // TODO: Note that the source file instance is created during construction
     // So every operation should use a new instance of the field manager, so updated tree/source is used before each operation
@@ -52,14 +53,13 @@ export abstract class BaseFieldManagerForEntity implements FieldManager {
       tree,
       `src/${dasherize(moduleName)}/entities/${dasherize(modelName)}.entity.ts`,
     );
-
     const fieldPropertyDeclarationNode = this.getFieldIdentifierNode(
       this.fieldName(),
       this.source
     )?.parent as PropertyDeclaration | undefined;
 
     this.indexDecoratorManager = new IndexDecoratorManager(
-      { index: this.field.index, source: this.source, field: this.field },
+      { index: this.field.index, source: this.source, field: this.field, modelEnableSoftDelete: this.modelEnableSoftDelete },
       fieldPropertyDeclarationNode,
     );
     this.columnDecoratorManager = new ColumnDecoratorManager(
@@ -78,7 +78,7 @@ export abstract class BaseFieldManagerForEntity implements FieldManager {
     this.manyToOneDecoratorManager = new ManyToOneDecoratorManager(
       {
         isManyToOne: this.isManyToOne(),
-        relationModelSingularName: this.field.relationModelSingularName,
+        relationCoModelSingularName: this.field.relationCoModelSingularName,
         relationCascade: this.field.relationCascade,
         required: this.field.required,
         source: this.source,
@@ -94,14 +94,14 @@ export abstract class BaseFieldManagerForEntity implements FieldManager {
         source: this.source,
         field: this.field,
         fieldName: this.fieldName(),
-        relationModelFieldName: this.field.relationModelFieldName
+        relationCoModelColumnName: this.field.relationCoModelColumnName
       },
     );
     this.manyToManyDecoratorManager = new ManyToManyDecoratorManager(
       {
         isManyToMany: this.isManyToMany(),
-        relationModelName: this.field.relationModelSingularName,
-        relationInverseFieldName: this.field.relationModelFieldName,
+        relationModelName: this.field.relationCoModelSingularName,
+        relationInverseFieldName: this.field.relationCoModelFieldName,
         relationCascade: this.field.relationCascade,
         owner: this.field.isRelationManyToManyOwner,
         source: this.source,
@@ -118,12 +118,12 @@ export abstract class BaseFieldManagerForEntity implements FieldManager {
         fieldName: this.fieldName(),
         modelName: this.modelName,
         relationJoinTableName: this.field.relationJoinTableName,
-        relationJoinColumnName: this.field.relationJoinColumnName,
-        joinColumnName: this. field.joinColumnName
+        relationJoinColumnName: this.field.relationCoModelColumnName,
+        joinColumnName: this.field.columnName
       },
     );
     this.uniqueIndexDecoratorManager = new UniqueIndexDecoratorManager(
-      { unique: this.field.unique, fieldName: this.fieldName(), source: this.source, field: this.field },
+      { unique: this.field.unique, fieldName: this.fieldName(), source: this.source, field: this.field, modelEnableSoftDelete: this.modelEnableSoftDelete},
       this.getClassNode(this.modelName, this.source)
     );
     this.oneToManyDecoratorManager = new OneToManyDecoratorManager(
@@ -457,7 +457,7 @@ export abstract class BaseFieldManagerForEntity implements FieldManager {
   }
 
   protected inverseRelationFieldName(): string {
-    return `${this.field.relationModelSingularName}s`;
+    return `${this.field.relationCoModelSingularName}s`;
   }
 
 

package/src/code-builder/lib/field/field-managers/bigint/BigIntFieldHandler.ts

@@ -6,12 +6,13 @@ export class BigIntFieldHandler implements FieldHandler {
   entityFieldManager: FieldManager;
   createDtoFieldManager: FieldManager;
   updateDtoFieldManager: FieldManager;
-  constructor(tree: any, moduleName: string, modelName: string, field: any) {
+  constructor(tree: any, moduleName: string, modelName: string, field: any, modelEnableSoftDelete: any) {
     this.entityFieldManager = new BigIntFieldManagerForEntity(
       tree,
       moduleName,
       modelName,
       field,
+      modelEnableSoftDelete
     );
     this.createDtoFieldManager = new BigIntFieldManagerForDto(
       tree,

package/src/code-builder/lib/field/field-managers/bigint/BigIntFieldManagerForEntity.ts

@@ -9,8 +9,8 @@ export class BigIntFieldManagerForEntity
 {
   source: ts.SourceFile;
 
-  constructor(tree: Tree, moduleName: string, modelName: string, field: any) {
-    super(tree, moduleName, modelName, field);
+  constructor(tree: Tree, moduleName: string, modelName: string, field: any, modelEnableSoftDelete: any) {
+    super(tree, moduleName, modelName, field, modelEnableSoftDelete);
   }
 
   fieldType(): FieldType {

package/src/code-builder/lib/field/field-managers/boolean/BooleanFieldHandler.ts

@@ -6,12 +6,13 @@ export class BooleanFieldHandler implements FieldHandler {
   entityFieldManager: FieldManager;
   createDtoFieldManager: FieldManager;
   updateDtoFieldManager: FieldManager
-  constructor(tree: any, moduleName: string, modelName: string, field: any) {
+  constructor(tree: any, moduleName: string, modelName: string, field: any, modelEnableSoftDelete: any) {
     this.entityFieldManager = new BooleanFieldManagerForEntity(
       tree,
       moduleName,
       modelName,
       field,
+      modelEnableSoftDelete
     );
     this.createDtoFieldManager = new BooleanFieldManagerForDto(
       tree,

package/src/code-builder/lib/field/field-managers/boolean/BooleanFieldManagerForEntity.ts

@@ -9,8 +9,8 @@ export class BooleanFieldManagerForEntity
 {
   source: ts.SourceFile;
 
-  constructor(tree: Tree, moduleName: string, modelName: string, field: any) {
-    super(tree, moduleName, modelName, field);
+  constructor(tree: Tree, moduleName: string, modelName: string, field: any, modelEnableSoftDelete: any) {
+    super(tree, moduleName, modelName, field, modelEnableSoftDelete);
   }
 
   fieldType(): FieldType {

package/src/code-builder/lib/field/field-managers/computed/ComputedFieldHandler.ts

@@ -11,12 +11,14 @@ export class ComputedFieldHandler implements FieldHandler {
     moduleName: string,
     modelName: string,
     field: string,
+    modelEnableSoftDelete: any
   ) {
     this.entityFieldManager = new ComputedFieldManagerForEntity(
       tree,
       moduleName,
       modelName,
       field,
+      modelEnableSoftDelete,
     );
     //Instantiate the entity and dto source files
   }

package/src/code-builder/lib/field/field-managers/computed/ComputedFieldManagerForEntity.ts

@@ -8,8 +8,8 @@ export class ComputedFieldManagerForEntity
   implements FieldManager {
   source: ts.SourceFile;
 
-  constructor(tree: Tree, moduleName: string, modelName: string, field: any) {
-    super(tree, moduleName, modelName, field);
+  constructor(tree: Tree, moduleName: string, modelName: string, field: any, modelEnableSoftDelete: any) {
+    super(tree, moduleName, modelName, field, modelEnableSoftDelete);
   }
 
   fieldType(): FieldType {

package/src/code-builder/lib/field/field-managers/date/DateFieldHandler.ts

@@ -6,12 +6,13 @@ export class DateFieldHandler implements FieldHandler {
   entityFieldManager: FieldManager;
   createDtoFieldManager: FieldManager;
   updateDtoFieldManager: FieldManager;
-  constructor(tree: any, moduleName: string, modelName: string, field: any) {
+  constructor(tree: any, moduleName: string, modelName: string, field: any, modelEnableSoftDelete: any) {
     this.entityFieldManager = new DateFieldManagerForEntity(
       tree,
       moduleName,
       modelName,
       field,
+      modelEnableSoftDelete
     );
     this.createDtoFieldManager = new DateFieldManagerForDto(
       tree,

package/src/code-builder/lib/field/field-managers/date/DateFieldManagerForEntity.ts

@@ -8,8 +8,8 @@ export class DateFieldManagerForEntity
   implements FieldManager {
   source: ts.SourceFile;
 
-  constructor(tree: Tree, moduleName: string, modelName: string, field: any) {
-    super(tree, moduleName, modelName, field);
+  constructor(tree: Tree, moduleName: string, modelName: string, field: any, modelEnableSoftDelete: any) {
+    super(tree, moduleName, modelName, field, modelEnableSoftDelete);
   }
 
   fieldType(): FieldType {