@solidstarters/solid-code-builder 1.0.11 → 1.0.12

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

@@ -1,12 +1,8 @@
-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 { Change } from '@schematics/angular/utility/change';
-import { ArrayDecoratorManager } from '../../decorator-managers/dto/ArrayDecoratorManager';
 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 { FieldChange, FieldManager, FieldType, ManagerForDtoOptions } from '../../FieldManager';
 import { BaseFieldManagerForDto } from '../base/BaseFieldManagerForDto';
 
 export class ManyToOneRelationFieldManagerForDto
@@ -18,31 +14,9 @@ export class ManyToOneRelationFieldManagerForDto
   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);
-    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,
-      );
-      //HACK: This is a hack to add the transform decorator to the inverse field
-      this.relationInverseDecoratorManagers.push(
-        new TransformDecoratorManager({ isTransform: true, type: this.transformType(), source: this.relationInverseSource, field: field })
-      );
-      //HACK: This is a hack to replace the optional decorator to the inverse field
-      this.relationInverseDecoratorManagers.push(
-        new OptionalDecoratorManager({ isApplyOptional: true, optional: true, source: this.relationInverseSource, field: field })
-      );
-    }
   }
 
   isString(): boolean {
@@ -87,36 +61,12 @@ export class ManyToOneRelationFieldManagerForDto
     };
   }
 
-  // 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 {
-    const type = this.transformType() //TODO Discuss if this needs to be Create Or Update DTO
-    const text = `${type}[]`
-    return {
-      text: text,
-      node: (_field: any) =>
-        ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode(
-          ts.factory.createIdentifier(type),
-          undefined
-        )),
-    };
-  }
-
-  private transformType(): string {
-    return  `Update${classify(this.modelName)}Dto`;
-  }
-
   override addAdditionalField(): FieldChange[] {
     const fieldChanges: FieldChange[] = [];
 
     // Add the userKey field to the main entity
     fieldChanges.push(this.addAdditionalUserKeyField());
 
-    if (this.field.relationCreateInverse) {
-      fieldChanges.push(this.addAdditionalInverseField());
-      fieldChanges.push(this.addAdditionalInverseIdsField());
-      fieldChanges.push(this.addAdditionalInverseCommandsField());
-    }
-
     return fieldChanges;
   }
 
@@ -136,71 +86,12 @@ export class ManyToOneRelationFieldManagerForDto
     return fieldChange;
   }
   
-  private addAdditionalInverseCommandsField(): FieldChange {
-    const fieldName = `${this.field.relationModelFieldName ?? this.modelName}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) 
-    ];
-
-    //console.log(`\ncreate Dto addAdditionalInverseCommandsField ${fieldName} called ...`);
-
-    const fieldChange = this.addFieldInternal(fieldName, fieldType, decoratorManagers, field, modelName, source);
-
-    return fieldChange;
-  }
-
-  private addAdditionalInverseIdsField(): FieldChange {
-    const fieldName = `${this.field.relationModelFieldName ?? this.modelName}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 })
-    ]
-
-    //console.log(`\ncreate Dto addAdditionalInverseIdsField ${fieldName} called ...`);
-
-    const fieldChange = this.addFieldInternal(fieldName, fieldType, decoratorManagers, field, modelName, source);
-
-    return fieldChange;
-  }
-
-  private addAdditionalInverseField() {
-    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;
-    //console.log(`\ncreate Dto addAdditionalInverseField ${fieldName} called ...`);
-    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;
-  }
 
   override addOrUpdateAdditionalField(): FieldChange[] {
     const fieldChanges: FieldChange[] = [];
 
     // Add the userKey field to the main entity
     fieldChanges.push(this.updateAdditionalUserKeyField());
-    if (this.field.relationCreateInverse) {
-      fieldChanges.push(this.updateAdditionalInverseField());
-      fieldChanges.push(this.updateAdditionalInverseIdsField());
-      fieldChanges.push(this.updateAdditionalInverseCommandsField());
-    }
     return fieldChanges;
   }
 
@@ -230,126 +121,26 @@ export class ManyToOneRelationFieldManagerForDto
         }
   }
 
-  private updateAdditionalInverseCommandsField(): FieldChange {
-
-        const commandFieldName = `${this.field.relationModelFieldName ?? this.modelName}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;
-        //console.log(`\ncreate Dto updateAdditionalInverseCommandsField ${commandFieldName} called ...`);
-
-        if (commandField == null) {
-            return this.addAdditionalInverseCommandsField();
-        }
-        else {
-            //Update the command field
-            return this.updateFieldInternal(commandFieldName, commandFieldType, decoratorManagers, field, source)
-        }
-  }
-
-  private updateAdditionalInverseIdsField(): FieldChange {
-    const idsFieldName = `${this.field.relationModelFieldName ?? this.modelName}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;
-    //console.log(`\ncreate Dto updateAdditionalInverseIdsField ${idsFieldName} called ...`);
-
-    if (idsField == null) {
-        return this.addAdditionalInverseIdsField();
-    }
-    else {
-        //Update the ids field
-        return this.updateFieldInternal(idsFieldName, idsFieldType, decoratorManagers, field, source)
-    }
-
-  }
-
-  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.relationInverseDecoratorManagers;
-   
-    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;
-    }
-  }
-
-  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);
-  }
 
   override removeAdditionalField(): FieldChange[] {
     const fieldChanges: FieldChange[] = [];
+    
+    fieldChanges.push(this.removeAdditionalUserKeyField());
 
-    if (this.field.relationCreateInverse) {
-      fieldChanges.push(this.removeAdditionalInverseField());
-      fieldChanges.push(this.removeAdditionalInverseIdsField());
-      fieldChanges.push(this.removeAdditionalInverseCommandsField());
-    }
     return fieldChanges;
   }
 
-  removeAdditionalInverseField(): FieldChange {
-    const fieldName = this.additionalFieldName();
-    const source = this.relationInverseSource;
-    return this.removeFieldFor(fieldName, source);
-  }
-
-  removeAdditionalInverseIdsField(): FieldChange {
-    const fieldName = `${this.field.relationModelFieldName ?? this.modelName}Ids`;
-    const source = this.relationInverseSource;
+  private removeAdditionalUserKeyField(): FieldChange {
+    const fieldName = `${this.field.name}UserKey`;
+    const source = this.source;
     return this.removeFieldFor(fieldName, source);
   }
 
-  removeAdditionalInverseCommandsField(): FieldChange {
-    const fieldName = `${this.field.relationModelFieldName ?? this.modelName}Command`;
-    const source = this.relationInverseSource;
-    return this.removeFieldFor(fieldName, source);
-  }
 
   override fieldName(): string {
     return `${this.field.name}Id`;
   }
 
-  additionalFieldName(): string {
-    return this.field.relationModelFieldName ?? `${this.modelName}s`;
-  }
 
   protected isAdditionalFieldRequired(): boolean {
     return true;

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

@@ -1,9 +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 { OneToManyDecoratorManager } from '../../decorator-managers/entity/OneToManyDecoratorManager';
-import { DecoratorManager, FieldChange, FieldManager, FieldType, RelationType, createSourceFile, safeInsertImport } from '../../FieldManager';
+import { FieldChange, FieldManager, FieldType, safeInsertImport } from '../../FieldManager';
 import {
   BaseFieldManagerForEntity,
 } from '../base/BaseFieldManagerForEntity';
@@ -11,59 +9,11 @@ import {
 export class ManyToOneRelationFieldManagerForEntity
   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.oneToManyDecoratorManager = new OneToManyDecoratorManager(
-        {
-          isOneToMany: this.isOneToMany(),
-          relationCascade: this.field.relationCascade,
-          source: this.relationInverseSource,
-          field: this.field,
-          fieldName: this.fieldName(),
-          modelName: this.modelName,
-        },
-      );
-    }
-  }
-
-  fieldName(): string {
-    switch(this.field.relationType) {
-      case RelationType.ManyToOne:
-        return super.fieldName();
-      case RelationType.ManyToMany:
-        return `${this.field.name}s`;
-      default:
-        throw new Error(`Unsupported relation type: ${this.field.relationType}`);
-    }
-  }
 
   fieldType(): FieldType {
-    switch(this.field.relationType) {
-      case RelationType.ManyToOne:
-        return this.manyToOneFieldType();
-      case RelationType.ManyToMany:
-        return this.manyToManyFieldType();
-      default:
-        throw new Error(`Unsupported relation type: ${this.field.relationType}`);
-    }
+    return this.manyToOneFieldType();
   }
 
-
   private manyToOneFieldType(): FieldType {
     return {
       text: classify(this.field.relationModelSingularName),
@@ -76,20 +26,6 @@ export class ManyToOneRelationFieldManagerForEntity
     };
   }
 
-  private manyToManyFieldType(): FieldType {
-    const type = `${classify(this.field.relationModelSingularName)}`
-    const text = `${type}[]`
-    return {
-      text: text,
-      node: (_field: any) => ts.factory.createArrayTypeNode(
-        ts.factory.createTypeReferenceNode(
-          ts.factory.createIdentifier(type),
-          undefined
-        )
-      ),
-    };
-  }
-
   override addField(): FieldChange[] {
     const fieldChanges = super.addField();
     if (fieldChanges.length > 0 && this.modelName !== this.field.relationModelSingularName) { 
@@ -114,112 +50,5 @@ export class ManyToOneRelationFieldManagerForEntity
     return safeInsertImport(this.source, classify(this.field.relationModelSingularName), relatedEntityPath, this.moduleName);
   }
 
-  private isOneToMany(): boolean {
-    return (this.field.type === 'relation' && this.field.relationType === RelationType.ManyToOne && this.field.relationCreateInverse);
-  }
-
-  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;
-    }
-  }
-
-  additionalFieldName(): string { // The inverse field type will remain the same for both one-to-many and many-to-many relations
-    return this.field.relationModelFieldName ?? `${this.modelName}s`;
-  }
-
-  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
-        )),
-    };
-  }
-
-  private additionalDecoratorManagers(): DecoratorManager[] {
-    return [this.oneToManyDecoratorManager];
-  }
   
 }

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

@@ -0,0 +1,52 @@
+import { DtoSourceType, FieldChange, FieldHandler, FieldManager, ManagerForDtoOptions } from '../../FieldManager';
+import { OneToManyRelationFieldManagerForDto } from './OneToManyRelationFieldManagerForDto';
+import { OneToManyRelationFieldManagerForEntity } from './OneToManyRelationFieldManagerForEntity';
+
+
+export class OneToManyRelationFieldHandler implements FieldHandler {
+  entityFieldManager: FieldManager;
+  createDtoFieldManager: FieldManager;
+  updateDtoFieldManager: FieldManager;
+  constructor(tree: any, moduleName: string, modelName: string, field: any) {
+    this.entityFieldManager = new OneToManyRelationFieldManagerForEntity(
+      tree,
+      moduleName,
+      modelName,
+      field,
+    );
+    this.createDtoFieldManager = new OneToManyRelationFieldManagerForDto(
+      tree,
+      moduleName,
+      modelName,
+      field,
+      new ManagerForDtoOptions(DtoSourceType.Create),
+    );
+    this.updateDtoFieldManager = new OneToManyRelationFieldManagerForDto(
+      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()];
+  }
+}