@solidstarters/solid-code-builder 1.0.11 → 1.0.13

package/src/code-builder/lib/field/field-managers/relation/ManyToManyInverseRelationFieldHandler.ts

@@ -0,0 +1,52 @@
+import { DtoSourceType, FieldChange, FieldHandler, FieldManager, ManagerForDtoOptions } from '../../FieldManager';
+import { ManyToManyInverseRelationFieldManagerForDto } from './ManyToManyInverseRelationFieldManagerForDto';
+import { ManyToManyInverseRelationFieldManagerForEntity } from './ManyToManyInverseRelationFieldManagerForEntity';
+
+
+export class ManyToManyInverseRelationFieldHandler implements FieldHandler {
+  entityFieldManager: FieldManager;
+  createDtoFieldManager: FieldManager;
+  updateDtoFieldManager: FieldManager;
+  constructor(tree: any, moduleName: string, modelName: string, field: any) {
+    this.entityFieldManager = new ManyToManyInverseRelationFieldManagerForEntity(
+      tree,
+      moduleName,
+      modelName,
+      field,
+    );
+    this.createDtoFieldManager = new ManyToManyInverseRelationFieldManagerForDto(
+      tree,
+      moduleName,
+      modelName,
+      field,
+      new ManagerForDtoOptions(DtoSourceType.Create),
+    );
+    this.updateDtoFieldManager = new ManyToManyInverseRelationFieldManagerForDto(
+      tree,
+      moduleName,
+      modelName,
+      field,
+      new ManagerForDtoOptions(DtoSourceType.Update),
+    );
+  }
+  updateEntityField(): FieldChange[] {
+    return this.entityFieldManager.updateField();
+  }
+  updateDtoField(): FieldChange[] {
+    return [...this.createDtoFieldManager.updateField(), ...this.updateDtoFieldManager.updateField()];
+  }
+  removeEntityField(): FieldChange[] {
+    return this.entityFieldManager.removeField();
+  }
+  removeDtoField(): FieldChange[] {
+    return [...this.createDtoFieldManager.removeField(), ...this.updateDtoFieldManager.removeField()];
+  }
+
+  addEntityField(): FieldChange[] {
+    return this.entityFieldManager.addField();
+  }
+
+  addDtoField(): FieldChange[] {
+    return [...this.createDtoFieldManager.addField(), ...this.updateDtoFieldManager.addField()];
+  }
+}

package/src/code-builder/lib/field/field-managers/relation/ManyToManyInverseRelationFieldManagerForDto.ts

@@ -0,0 +1,8 @@
+import { FieldManager } from '../../FieldManager';
+import { ManyToManyRelationFieldManagerForDto } from './ManyToManyRelationFieldManagerForDto';
+
+// For DTO's, the inverse relation behaivour is the same as the normal relation
+export class ManyToManyInverseRelationFieldManagerForDto
+    extends ManyToManyRelationFieldManagerForDto
+    implements FieldManager {
+}

package/src/code-builder/lib/field/field-managers/relation/ManyToManyInverseRelationFieldManagerForEntity.ts

@@ -0,0 +1,8 @@
+import { FieldManager } from '../../FieldManager';
+import { ManyToManyRelationFieldManagerForEntity } from './ManyToManyRelationFieldManagerForEntity';
+
+export class ManyToManyInverseRelationFieldManagerForEntity
+    extends ManyToManyRelationFieldManagerForEntity
+    implements FieldManager {
+
+}

package/src/code-builder/lib/field/field-managers/relation/ManyToManyRelationFieldManagerForDto.ts

@@ -6,7 +6,7 @@ import { ArrayDecoratorManager } from '../../decorator-managers/dto/ArrayDecorat
 import { OptionalDecoratorManager } from '../../decorator-managers/dto/OptionalDecoratorManager';
 import { StringDecoratorManager } from '../../decorator-managers/dto/StringDecoratorManager';
 import { TransformDecoratorManager } from '../../decorator-managers/dto/TransformDecoratorManager';
-import { DecoratorManager, DecoratorType, DtoSourceType, FieldChange, FieldManager, FieldType, ManagerForDtoOptions, createSourceFile, safeInsertImport } from '../../FieldManager';
+import { DecoratorType, FieldChange, FieldManager, FieldType, ManagerForDtoOptions, safeInsertImport } from '../../FieldManager';
 import { BaseFieldManagerForDto } from '../base/BaseFieldManagerForDto';
 
 export class ManyToManyRelationFieldManagerForDto
@@ -18,8 +18,6 @@ export class ManyToManyRelationFieldManagerForDto
     isBoolean(): boolean {
         return false;
     }
-    relationInverseSource: ts.SourceFile;
-    relationInverseDecoratorManagers: DecoratorManager[];
 
     constructor(tree: Tree, moduleName: string, modelName: string, field: any, options: ManagerForDtoOptions) {
         super(tree, moduleName, modelName, {...field, required: false}, options);
@@ -28,32 +26,11 @@ export class ManyToManyRelationFieldManagerForDto
             this.source,
             DecoratorType.Array,
             DecoratorType.ValidateNested,
-            // DecoratorType.Transform,
         )];
         this.decoratorManagers.push(
             new TransformDecoratorManager({ isTransform: true, type: this.transformType(this.field.relationModelSingularName), source: this.source, field: field })
         );
         
-        // TODO : inverse source file logic is required, but needs to be handled in a better way
-        if (this.field.relationCreateInverse) {
-            const relatedEntityFileName = (this.options.sourceType === DtoSourceType.Create) ? `create-${dasherize(this.field.relationModelSingularName)}.dto.ts` : `update-${dasherize(this.field.relationModelSingularName)}.dto.ts`;
-            const relatedEntityPath = this.field.relationModelModuleName ? `src/${dasherize(this.field.relationModelModuleName)}/dtos/${relatedEntityFileName}` : `src/${dasherize(moduleName)}/dtos/${relatedEntityFileName}`;
-            this.relationInverseSource = createSourceFile(tree, relatedEntityPath);
-            this.relationInverseDecoratorManagers = this.getFieldDecoratorManagers(
-                this.field,
-                this.relationInverseSource,
-                DecoratorType.Array,
-                DecoratorType.ValidateNested,
-                // DecoratorType.Transform,
-              );
-            this.relationInverseDecoratorManagers.push(
-                new TransformDecoratorManager({ isTransform: true, type: this.transformType(this.modelName), source: this.relationInverseSource, field: field })
-            );
-            this.relationInverseDecoratorManagers.push(
-                new OptionalDecoratorManager({ isApplyOptional: true, optional: true, source: this.relationInverseSource, field: field })
-            );
-      
-        }
     }
 
     isString(): boolean {
@@ -92,11 +69,6 @@ export class ManyToManyRelationFieldManagerForDto
         return this.manyToManyFieldType(this.field.relationModelSingularName)
     }
 
-    // This field type is used in the case of one-to-many relation, when we generate the inverse field in the related entity
-    additionalFieldType(): FieldType {
-        return this.manyToManyFieldType(this.modelName)
-    }
-
     private transformType(forModelName: string): string {
         return `Update${classify(forModelName)}Dto`;
     }
@@ -123,44 +95,9 @@ export class ManyToManyRelationFieldManagerForDto
         // Add the command field to the main entity
         fieldChanges.push(this.addAdditionalCommandField());
 
-        // Add the inverse field to the related entity
-        if (this.field.relationCreateInverse) {
-            fieldChanges.push(this.addAdditionalInverseField());
-            fieldChanges.push(this.addAdditionalInverseIdsField());
-            fieldChanges.push(this.addAdditionalInverseCommandsField());
-        }
         return fieldChanges;
     }
     
-    private addAdditionalInverseIdsField(): FieldChange {
-        const fieldName = `${this.field.relationModelFieldName}Ids`;
-        const fieldType = "number[]";
-        const source= this.relationInverseSource
-        const field = this.field
-        const modelName = this.field.relationModelSingularName        
-        const decoratorManagers = [
-            new OptionalDecoratorManager({ isApplyOptional: true, optional: true, source: source, field: field }),
-            new ArrayDecoratorManager({ isArray: true, source: source, field: field })
-        ]
-
-        return this.addFieldInternal(fieldName, fieldType, decoratorManagers, field, modelName, source);
-    }
-
-    private addAdditionalInverseCommandsField(): FieldChange {
-        const fieldName = `${this.field.relationModelFieldName}Command`;
-        const fieldType = "string";
-        const source= this.relationInverseSource
-        const field = this.field
-        const modelName = this.field.relationModelSingularName        
-        const decoratorManagers = [
-            new StringDecoratorManager({ isString: true, source: source, field: field }),
-            new OptionalDecoratorManager({ isApplyOptional: true, optional: true, source: source, field: field }),
-            // TODO pending @IsEnum(RelationFieldsCommand) 
-        ]
-
-        return this.addFieldInternal(fieldName, fieldType, decoratorManagers, field, modelName, source);
-    }
-
     private addAdditionalIdsField() : FieldChange{
         const fieldName = `${this.field.name}Ids`;
         const fieldType = "number[]";
@@ -191,28 +128,22 @@ export class ManyToManyRelationFieldManagerForDto
 
     }
 
-    private inverseFieldImport(modelName: string, currentModuleName: string, source: ts.SourceFile): Change {
-        const inverseEntityImportName = `update-${dasherize(modelName)}.dto`;
-        const modulePath = `src/${currentModuleName}`;
-        const inverseEntityPath = `${modulePath}/dtos/${inverseEntityImportName}`;
-        return safeInsertImport(source, `Update${classify(modelName)}Dto`, inverseEntityPath, currentModuleName);
-    }
     
-    private addAdditionalInverseField() : FieldChange {
-        const fieldName = this.additionalFieldName();
-        const fieldType = this.additionalFieldType().text;
-        const source= this.relationInverseSource
-        const field = this.field
-        const modelName = this.field.relationModelSingularName        
-        const decoratorManagers = this.relationInverseDecoratorManagers
-        const fieldChange =  this.addFieldInternal(fieldName, fieldType, decoratorManagers, field, modelName, source);
-        if (this.modelName !== this.field.relationModelSingularName) {
-            const currentModelName = this.modelName;
-            const currentModuleName = this.moduleName;
-            fieldChange.changes.push(this.inverseFieldImport(currentModelName, currentModuleName, source));
-        }
-        return fieldChange;
-    }
+    // private addAdditionalInverseField() : FieldChange {
+    //     const fieldName = this.additionalFieldName();
+    //     const fieldType = this.additionalFieldType().text;
+    //     const source= this.relationInverseSource
+    //     const field = this.field
+    //     const modelName = this.field.relationModelSingularName        
+    //     const decoratorManagers = this.relationInverseDecoratorManagers
+    //     const fieldChange =  this.addFieldInternal(fieldName, fieldType, decoratorManagers, field, modelName, source);
+    //     if (this.modelName !== this.field.relationModelSingularName) {
+    //         const currentModelName = this.modelName;
+    //         const currentModuleName = this.moduleName;
+    //         fieldChange.changes.push(this.inverseFieldImport(currentModelName, currentModuleName, source));
+    //     }
+    //     return fieldChange;
+    // }
 
     //TODO: Can be improved to avoid duplicate code
     override addOrUpdateAdditionalField(): FieldChange[] {
@@ -223,87 +154,9 @@ export class ManyToManyRelationFieldManagerForDto
         // Add or update the command field
         fieldChanges.push(this.updateAdditionalCommandField());
 
-        if (this.field.relationCreateInverse) {
-            fieldChanges.push(this.updateAdditionalInverseField());
-            fieldChanges.push(this.updateAdditionalInverseIdsField());
-            fieldChanges.push(this.updateAdditionalInverseCommandsField());
-        }
         return fieldChanges;
     }
 
-    updateAdditionalInverseField(): FieldChange {
-       const inverseFieldName = this.field.relationModelFieldName;
-       const inverseFieldType = this.manyToManyFieldType(this.modelName).node(this.field);
-       const source= this.relationInverseSource
-       const field = this.field
-       const inverseDecoratorManagers = this.relationInverseDecoratorManagers
-       
-       const inverseField = this.getFieldIdentifierNode(
-              inverseFieldName,
-              source
-         )?.parent as PropertyDeclaration; 
-         if (inverseField == null) {
-              return this.addAdditionalInverseField();
-         }
-         else {
-                //Update the inverse field
-                const fieldChange = this.updateFieldInternal(inverseFieldName, inverseFieldType, inverseDecoratorManagers, field, source)
-                if (this.modelName !== this.field.relationModelSingularName) {
-                    const currentModelName = this.modelName;
-                    const currentModuleName = this.moduleName;
-                    fieldChange.changes.push(this.inverseFieldImport(currentModelName, currentModuleName, source));
-                }
-                return fieldChange;
-         }
-    }
-
-    updateAdditionalInverseIdsField(): FieldChange {
-        const idsFieldName = `${this.field.relationModelFieldName}Ids`
-        const idsFieldType = ts.factory.createArrayTypeNode(ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword));
-        const source = this.relationInverseSource
-        const field = this.field
-        const decoratorManagers = [
-            new OptionalDecoratorManager({ isApplyOptional: true, optional: true, source: source, field: field }),
-            new ArrayDecoratorManager({ isArray: true, source: source, field: field })
-        ]
- 
-        const idsField = this.getFieldIdentifierNode(
-            idsFieldName,
-            source
-        )?.parent as PropertyDeclaration;
-        if (idsField == null) {
-            return this.addAdditionalInverseIdsField();
-        }
-        else {
-            //Update the ids field
-            return this.updateFieldInternal(idsFieldName, idsFieldType, decoratorManagers, field, source)
-        }
-    }
-
-    updateAdditionalInverseCommandsField(): FieldChange {
-        const commandFieldName = `${this.field.relationModelFieldName}Command`
-        const commandFieldType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
-        const source = this.relationInverseSource
-        const field = this.field
-        const decoratorManagers = [
-            new StringDecoratorManager({ isString: true, source: source, field: field }),
-            new OptionalDecoratorManager({ isApplyOptional: true, optional: true, source: source, field: field }),
-            // TODO pending @IsEnum(RelationFieldsCommand) 
-        ]
- 
-        const commandField = this.getFieldIdentifierNode(
-            commandFieldName,
-            source
-        )?.parent as PropertyDeclaration;
-        if (commandField == null) {
-            return this.addAdditionalInverseCommandsField();
-        }
-        else {
-            //Update the command field
-            return this.updateFieldInternal(commandFieldName, commandFieldType, decoratorManagers, field, source)
-        }
-    }
-
     private updateAdditionalIdsField(): FieldChange {
         const idsFieldName = `${this.field.name}Ids`
         const source = this.source
@@ -364,12 +217,6 @@ export class ManyToManyRelationFieldManagerForDto
         // Add the command field to the main entity
         fieldChanges.push(this.removeAdditionalCommandField());
 
-        // Add the inverse field to the related entity
-        if (this.field.relationCreateInverse) {
-            fieldChanges.push(this.removeAdditionalInverseField());
-            fieldChanges.push(this.removeAdditionalInverseIdsField());
-            fieldChanges.push(this.removeAdditionalInverseCommandsField());
-        }
         return fieldChanges;
     }
 
@@ -383,34 +230,14 @@ export class ManyToManyRelationFieldManagerForDto
         const source = this.source;
         return this.removeFieldFor(fieldName, source);
     }
-    removeAdditionalInverseField(): FieldChange {
-        const fieldName = this.additionalFieldName();
-        const source = this.relationInverseSource;
-        return this.removeFieldFor(fieldName, source);
-    }
-    removeAdditionalInverseIdsField(): FieldChange {
-        const fieldName = `${this.field.relationModelFieldName}Ids`;
-        const source = this.relationInverseSource;
-        return this.removeFieldFor(fieldName, source);
-    }
-    removeAdditionalInverseCommandsField(): FieldChange {
-        const fieldName = `${this.field.relationModelFieldName}Command`;
-        const source = this.relationInverseSource;
-        return this.removeFieldFor(fieldName, source);
-    }
 
     //TODO: Need to revise the algorithm to generate multiple fields as part of single solid field type
     override fieldName(): string {
         return `${this.field.name}`;
     }
 
-    additionalFieldName(): string {
-        return this.field.relationModelFieldName;
-    }
-
     protected isAdditionalFieldRequired(): boolean {
         return true
-        // return this.field.relationCreateInverse;
     }
 
     override addField(): FieldChange[] {

package/src/code-builder/lib/field/field-managers/relation/ManyToManyRelationFieldManagerForEntity.ts

@@ -1,10 +1,7 @@
 import { classify, dasherize } from '@angular-devkit/core/src/utils/strings';
-import { Tree } from '@angular-devkit/schematics';
-import ts, { PropertyDeclaration } from '@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript';
+import ts from '@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript';
 import { Change } from '@schematics/angular/utility/change';
-import { ManyToManyDecoratorManager } from '../../decorator-managers/entity/ManyToManyDecoratorManager';
-import { OneToManyDecoratorManager } from '../../decorator-managers/entity/OneToManyDecoratorManager';
-import { DecoratorManager, FieldChange, FieldManager, FieldType, createSourceFile, safeInsertImport } from '../../FieldManager';
+import { FieldChange, FieldManager, FieldType, safeInsertImport } from '../../FieldManager';
 import {
     BaseFieldManagerForEntity,
 } from '../base/BaseFieldManagerForEntity';
@@ -12,39 +9,6 @@ import {
 export class ManyToManyRelationFieldManagerForEntity
     extends BaseFieldManagerForEntity
     implements FieldManager {
-    source: ts.SourceFile;
-    relationInverseSource: ts.SourceFile;
-
-    oneToManyDecoratorManager: OneToManyDecoratorManager;
-    inverseManyToManyDecoratorManager: DecoratorManager;
-
-
-    constructor(tree: Tree, moduleName: string, modelName: string, field: any) {
-        super(tree, moduleName, modelName, field);
-        if (this.isAdditionalFieldRequired()) {
-            const relatedEntityFileName = `${dasherize(this.field.relationModelSingularName)}.entity.ts`;
-            const relatedEntityPath = this.field.relationModelModuleName ? `src/${dasherize(this.field.relationModelModuleName)}/entities/${relatedEntityFileName}` : `src/${dasherize(moduleName)}/entities/${relatedEntityFileName}`;
-            this.relationInverseSource = createSourceFile( //TODO "src/iam/dtos/create-user.dto.ts" does not exist. If an entity is used in a many-to-one relation, the create-entity.dto.ts file should be exist.
-                tree,
-                relatedEntityPath,
-            );
-
-            this.inverseManyToManyDecoratorManager = new ManyToManyDecoratorManager(
-                {
-                    isManyToMany: this.isInverseManyToMany(),
-                    relationModelName: this.modelName,
-                    relationInverseFieldName: this.fieldName(),
-                    relationCascade: this.field.relationCascade,
-                    owner: false,
-                    source: this.relationInverseSource,
-                    field: this.field,
-                    fieldName: this.fieldName(),
-                    modelName: this.modelName,
-                },
-            );
-
-        }
-    }
 
     fieldName(): string {
         return `${this.field.name}`;
@@ -92,113 +56,4 @@ export class ManyToManyRelationFieldManagerForEntity
         return safeInsertImport(this.source, classify(this.field.relationModelSingularName), relatedEntityPath, this.moduleName);
     }
 
-    override removeAdditionalField(): FieldChange {
-        const changes: Change[] = [];
-        if (this.isFieldPresent(this.additionalFieldName(), this.relationInverseSource)) {
-            console.log(`\nEntity removeField ${this.additionalFieldName()} called ...`);
-            changes.push(...this.removeFieldFor(this.additionalFieldName(), this.relationInverseSource).changes);
-        }
-        return {
-            filePath: this.relationInverseSource.fileName,
-            field: this.field,
-            changes: changes,
-        };
-    }
-
-    override isAdditionalFieldRequired(): boolean {
-        return (this.field.type === 'relation' && this.field.relationCreateInverse);
-    }
-
-    override addAdditionalField(): FieldChange[] {
-        const fieldChanges: FieldChange[] = [];
-    
-        if (this.field.relationCreateInverse) {
-          fieldChanges.push(this.addAdditionalInverseField());
-        }
-    
-        return fieldChanges;
-    }
-    
-    private addAdditionalInverseField(): FieldChange {
-        const fieldName = this.additionalFieldName();
-        const fieldType = this.additionalFieldType().text;
-        const source= this.relationInverseSource
-        const field = this.field
-        const modelName = this.field.relationModelSingularName        
-        const decoratorManagers = this.additionalDecoratorManagers();
-    
-        const fieldChange = this.addFieldInternal(fieldName, fieldType, decoratorManagers, field, modelName, source);
-        if (this.modelName !== this.field.relationModelSingularName) {
-            const currentModelName = this.modelName;
-            const currentModuleName = this.moduleName;
-            fieldChange.changes.push(this.inverseFieldImport(currentModelName, currentModuleName, source));
-        }
-        return fieldChange;    
-    }
-
-    private inverseFieldImport(modelName: string, currentModuleName: string, source: ts.SourceFile): Change {
-        const inverseEntityImportName = `${dasherize(modelName)}.entity`;
-        const modulePath = `src/${currentModuleName}`;
-        
-        const inverseEntityPath = `${modulePath}/entities/${inverseEntityImportName}`;
-    
-        return safeInsertImport(source, `${classify(modelName)}`, inverseEntityPath, currentModuleName);
-    }
-
-    override addOrUpdateAdditionalField(): FieldChange[] {
-        const fieldChanges: FieldChange[] = [];
-
-        if (this.field.relationCreateInverse) {
-            fieldChanges.push(this.updateAdditionalInverseField());
-        }
-        return fieldChanges;
-    }
-    
-    private updateAdditionalInverseField() : FieldChange{
-        const fieldName = this.additionalFieldName();
-        const fieldType = this.additionalFieldType().node(this.field);
-        const source = this.relationInverseSource;
-        const field = this.field;
-        const decoratorManagers = this.additionalDecoratorManagers();
-       
-        const inverseField = this.getFieldIdentifierNode(fieldName, source)?.parent as PropertyDeclaration;
-        if (inverseField == null) {
-          return this.addAdditionalInverseField();
-        }
-        else {
-          const fieldChange = this.updateFieldInternal(fieldName, fieldType, decoratorManagers, field, source); 
-          if (this.modelName !== this.field.relationModelSingularName) {
-            const currentModelName = this.modelName;
-            const currentModuleName = this.moduleName;
-            fieldChange.changes.push(this.inverseFieldImport(currentModelName, currentModuleName, source));
-          }
-          return fieldChange;
-        }
-      }
-    
-
-    additionalFieldType(): FieldType { // The inverse field type will remain the same for both one-to-many and many-to-many relations
-        const type = `${classify(this.modelName)}`
-        const text = `${type}[]`
-        return {
-            text: text,
-            node: (_field: any) =>
-                ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode(
-                    ts.factory.createIdentifier(type),
-                    undefined
-                )),
-        };
-    }
-
-    additionalFieldName(): string { // The inverse field type will remain the same for both one-to-many and many-to-many relations
-        return this.field.relationModelFieldName;
-    }
-
-    private additionalDecoratorManagers(): DecoratorManager[] {
-        return [this.inverseManyToManyDecoratorManager];
-    }
-
-    private isInverseManyToMany(): boolean {
-        return (this.isManyToMany() && this.field.relationCreateInverse);
-    }
 }