@solidstarters/solid-code-builder 1.0.0

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

@@ -0,0 +1,203 @@
+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 { insertImport } from '@schematics/angular/utility/ast-utils';
+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 {
+    BaseFieldManagerForEntity,
+} from '../base/BaseFieldManagerForEntity';
+
+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}`;
+    }
+
+    fieldType(): FieldType {
+        return this.manyToManyFieldType();
+    }
+
+    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) {
+            const mainField = fieldChanges[0]; // The 1st field change is the main field change, related to the entity source file
+            mainField.changes.push(this.relatedFieldImport());
+        }
+        return fieldChanges
+    }
+
+    override updateField(): FieldChange[] {
+        const fieldChanges = super.updateField();
+        if (fieldChanges.length > 0 && this.modelName !== this.field.relationModelSingularName) {
+            const mainField = fieldChanges[0]; // The 1st field change is the main field change, related to the entity source file
+            mainField.changes.push(this.relatedFieldImport());
+        }
+        return fieldChanges
+    }
+
+    relatedFieldImport(): Change {
+        const relatedEntityImportName = `${dasherize(this.field.relationModelSingularName)}.entity`;
+        const relatedEntityPath = this.field.relationModelModuleName ? `src/${dasherize(this.field.relationModelModuleName)}/entities/${relatedEntityImportName}` : `./${relatedEntityImportName}`;
+        return insertImport(this.source, this.source.fileName, classify(this.field.relationModelSingularName), relatedEntityPath);
+    }
+
+    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, moduleName: string, source: ts.SourceFile): Change {
+        const inverseEntityImportName = `${dasherize(modelName)}.entity`;
+        const inverseEntityPath = `src/${moduleName}/entities/${inverseEntityImportName}`;
+    
+        return safeInsertImport(source, `${classify(modelName)}`, inverseEntityPath);
+    }
+
+    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);
+    }
+}

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

@@ -0,0 +1,13 @@
+import { FieldChange, FieldHandler, FieldManager } from '../../FieldManager';
+export declare class ManyToOneRelationFieldHandler implements FieldHandler {
+    entityFieldManager: FieldManager;
+    createDtoFieldManager: FieldManager;
+    updateDtoFieldManager: FieldManager;
+    constructor(tree: any, moduleName: string, modelName: string, field: any);
+    updateEntityField(): FieldChange[];
+    updateDtoField(): FieldChange[];
+    removeEntityField(): FieldChange[];
+    removeDtoField(): FieldChange[];
+    addEntityField(): FieldChange[];
+    addDtoField(): FieldChange[];
+}

package/src/code-builder/lib/field/field-managers/relation/ManyToOneRelationFieldHandler.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToOneRelationFieldHandler = void 0;
+const FieldManager_1 = require("../../FieldManager");
+const ManyToOneRelationFieldManagerForDto_1 = require("./ManyToOneRelationFieldManagerForDto");
+const ManyToOneRelationFieldManagerForEntity_1 = require("./ManyToOneRelationFieldManagerForEntity");
+class ManyToOneRelationFieldHandler {
+    constructor(tree, moduleName, modelName, field) {
+        this.entityFieldManager = new ManyToOneRelationFieldManagerForEntity_1.ManyToOneRelationFieldManagerForEntity(tree, moduleName, modelName, field);
+        this.createDtoFieldManager = new ManyToOneRelationFieldManagerForDto_1.ManyToOneRelationFieldManagerForDto(tree, moduleName, modelName, field, new FieldManager_1.ManagerForDtoOptions(FieldManager_1.DtoSourceType.Create));
+        this.updateDtoFieldManager = new ManyToOneRelationFieldManagerForDto_1.ManyToOneRelationFieldManagerForDto(tree, moduleName, modelName, field, new FieldManager_1.ManagerForDtoOptions(FieldManager_1.DtoSourceType.Update));
+    }
+    updateEntityField() {
+        return this.entityFieldManager.updateField();
+    }
+    updateDtoField() {
+        return [...this.createDtoFieldManager.updateField(), ...this.updateDtoFieldManager.updateField()];
+    }
+    removeEntityField() {
+        return this.entityFieldManager.removeField();
+    }
+    removeDtoField() {
+        return [...this.createDtoFieldManager.removeField(), ...this.updateDtoFieldManager.removeField()];
+    }
+    addEntityField() {
+        return this.entityFieldManager.addField();
+    }
+    addDtoField() {
+        return [...this.createDtoFieldManager.addField(), ...this.updateDtoFieldManager.addField()];
+    }
+}
+exports.ManyToOneRelationFieldHandler = ManyToOneRelationFieldHandler;
+//# sourceMappingURL=ManyToOneRelationFieldHandler.js.map

package/src/code-builder/lib/field/field-managers/relation/ManyToOneRelationFieldHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ManyToOneRelationFieldHandler.js","sourceRoot":"","sources":["ManyToOneRelationFieldHandler.ts"],"names":[],"mappings":";;;AAAA,qDAAkH;AAClH,+FAA4F;AAC5F,qGAAkG;AAGlG,MAAa,6BAA6B;IAIxC,YAAY,IAAS,EAAE,UAAkB,EAAE,SAAiB,EAAE,KAAU;QACtE,IAAI,CAAC,kBAAkB,GAAG,IAAI,+EAAsC,CAClE,IAAI,EACJ,UAAU,EACV,SAAS,EACT,KAAK,CACN,CAAC;QACF,IAAI,CAAC,qBAAqB,GAAG,IAAI,yEAAmC,CAClE,IAAI,EACJ,UAAU,EACV,SAAS,EACT,KAAK,EACL,IAAI,mCAAoB,CAAC,4BAAa,CAAC,MAAM,CAAC,CAC/C,CAAC;QACF,IAAI,CAAC,qBAAqB,GAAG,IAAI,yEAAmC,CAClE,IAAI,EACJ,UAAU,EACV,SAAS,EACT,KAAK,EACL,IAAI,mCAAoB,CAAC,4BAAa,CAAC,MAAM,CAAC,CAC/C,CAAC;IACJ,CAAC;IACD,iBAAiB;QACf,OAAO,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,CAAC;IAC/C,CAAC;IACD,cAAc;QACZ,OAAO,CAAC,GAAG,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,EAAE,GAAG,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,CAAC,CAAC;IACpG,CAAC;IACD,iBAAiB;QACf,OAAO,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,CAAC;IAC/C,CAAC;IACD,cAAc;QACZ,OAAO,CAAC,GAAG,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,EAAE,GAAG,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,CAAC,CAAC;IACpG,CAAC;IAED,cAAc;QACZ,OAAO,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;IAC5C,CAAC;IAED,WAAW;QACT,OAAO,CAAC,GAAG,IAAI,CAAC,qBAAqB,CAAC,QAAQ,EAAE,EAAE,GAAG,IAAI,CAAC,qBAAqB,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC9F,CAAC;CACF;AA9CD,sEA8CC"}

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

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

@@ -0,0 +1,43 @@
+import { Tree } from '@angular-devkit/schematics';
+import ts from '@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript';
+import { DecoratorManager, FieldChange, FieldManager, FieldType, ManagerForDtoOptions } from '../../FieldManager';
+import { BaseFieldManagerForDto } from '../base/BaseFieldManagerForDto';
+export declare class ManyToOneRelationFieldManagerForDto extends BaseFieldManagerForDto implements FieldManager {
+    isJson(): boolean;
+    isBoolean(): boolean;
+    relationInverseSource: ts.SourceFile;
+    relationInverseDecoratorManagers: DecoratorManager[];
+    constructor(tree: Tree, moduleName: string, modelName: string, field: any, options: ManagerForDtoOptions);
+    isString(): boolean;
+    isNumber(): boolean;
+    isInt(): boolean;
+    isDecimal(): boolean;
+    isApplyRegex(): boolean;
+    isApplyRequired(): boolean;
+    isApplyMin(): boolean;
+    isApplyMax(): boolean;
+    isDate(): boolean;
+    isTransform(): boolean;
+    fieldType(): FieldType;
+    private manyToOneFieldType;
+    additionalFieldType(): FieldType;
+    private transformType;
+    addAdditionalField(): FieldChange[];
+    private addAdditionalUserKeyField;
+    private addAdditionalInverseCommandsField;
+    private addAdditionalInverseIdsField;
+    private addAdditionalInverseField;
+    addOrUpdateAdditionalField(): FieldChange[];
+    private updateAdditionalUserKeyField;
+    private updateAdditionalInverseCommandsField;
+    private updateAdditionalInverseIdsField;
+    private updateAdditionalInverseField;
+    private inverseFieldImport;
+    removeAdditionalField(): FieldChange[];
+    removeAdditionalInverseField(): FieldChange;
+    removeAdditionalInverseIdsField(): FieldChange;
+    removeAdditionalInverseCommandsField(): FieldChange;
+    fieldName(): string;
+    additionalFieldName(): string;
+    protected isAdditionalFieldRequired(): boolean;
+}

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

@@ -0,0 +1,294 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToOneRelationFieldManagerForDto = void 0;
+const strings_1 = require("@angular-devkit/core/src/utils/strings");
+const typescript_1 = __importDefault(require("@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript"));
+const ArrayDecoratorManager_1 = require("../../decorator-managers/dto/ArrayDecoratorManager");
+const OptionalDecoratorManager_1 = require("../../decorator-managers/dto/OptionalDecoratorManager");
+const TransformDecoratorManager_1 = require("../../decorator-managers/dto/TransformDecoratorManager");
+const FieldManager_1 = require("../../FieldManager");
+const BaseFieldManagerForDto_1 = require("../base/BaseFieldManagerForDto");
+const StringDecoratorManager_1 = require("../../decorator-managers/dto/StringDecoratorManager");
+class ManyToOneRelationFieldManagerForDto extends BaseFieldManagerForDto_1.BaseFieldManagerForDto {
+    isJson() {
+        return false;
+    }
+    isBoolean() {
+        return false;
+    }
+    constructor(tree, moduleName, modelName, field, options) {
+        super(tree, moduleName, modelName, Object.assign(Object.assign({}, field), { required: false }), options);
+        if (this.field.relationCreateInverse) {
+            const relatedEntityFileName = (this.options.sourceType === FieldManager_1.DtoSourceType.Create) ? `create-${(0, strings_1.dasherize)(this.field.relationModelSingularName)}.dto.ts` : `update-${(0, strings_1.dasherize)(this.field.relationModelSingularName)}.dto.ts`;
+            const relatedEntityPath = this.field.relationModelModuleName ? `src/${(0, strings_1.dasherize)(this.field.relationModelModuleName)}/dtos/${relatedEntityFileName}` : `src/${(0, strings_1.dasherize)(moduleName)}/dtos/${relatedEntityFileName}`;
+            this.relationInverseSource = (0, FieldManager_1.createSourceFile)(tree, relatedEntityPath);
+            this.relationInverseDecoratorManagers = this.getFieldDecoratorManagers(this.field, this.relationInverseSource, FieldManager_1.DecoratorType.Array, FieldManager_1.DecoratorType.ValidateNested);
+            //HACK: This is a hack to add the transform decorator to the inverse field
+            this.relationInverseDecoratorManagers.push(new TransformDecoratorManager_1.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_1.OptionalDecoratorManager({ isApplyOptional: true, optional: true, source: this.relationInverseSource, field: field }));
+        }
+    }
+    isString() {
+        return false;
+    }
+    isNumber() {
+        return false;
+    }
+    isInt() {
+        return true;
+    }
+    isDecimal() {
+        return false;
+    }
+    isApplyRegex() {
+        return false;
+    }
+    isApplyRequired() {
+        return true;
+    }
+    isApplyMin() {
+        return false;
+    }
+    isApplyMax() {
+        return false;
+    }
+    isDate() {
+        return false;
+    }
+    isTransform() {
+        return false;
+    }
+    fieldType() {
+        return this.manyToOneFieldType();
+    }
+    manyToOneFieldType() {
+        return {
+            text: 'number',
+            node: (_field) => typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.NumberKeyword),
+        };
+    }
+    // This field type is used in the case of one-to-many relation, when we generate the inverse field in the related entity
+    additionalFieldType() {
+        const type = this.transformType(); //TODO Discuss if this needs to be Create Or Update DTO
+        const text = `${type}[]`;
+        return {
+            text: text,
+            node: (_field) => typescript_1.default.factory.createArrayTypeNode(typescript_1.default.factory.createTypeReferenceNode(typescript_1.default.factory.createIdentifier(type), undefined)),
+        };
+    }
+    transformType() {
+        return `Update${(0, strings_1.classify)(this.modelName)}Dto`;
+    }
+    addAdditionalField() {
+        const fieldChanges = [];
+        // 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;
+    }
+    addAdditionalUserKeyField() {
+        const fieldName = `${this.field.name}UserKey`;
+        const fieldType = "string";
+        const source = this.source;
+        const field = this.field;
+        const modelName = this.modelName;
+        const decoratorManagers = [
+            new StringDecoratorManager_1.StringDecoratorManager({ isString: true, source: source, field: field }),
+            new OptionalDecoratorManager_1.OptionalDecoratorManager({ isApplyOptional: true, optional: true, source: source, field: field }),
+        ];
+        const fieldChange = this.addFieldInternal(fieldName, fieldType, decoratorManagers, field, modelName, source);
+        return fieldChange;
+    }
+    addAdditionalInverseCommandsField() {
+        var _a;
+        const fieldName = `${(_a = this.field.relationModelFieldName) !== null && _a !== void 0 ? _a : this.modelName}Command`;
+        const fieldType = "string";
+        const source = this.relationInverseSource;
+        const field = this.field;
+        const modelName = this.field.relationModelSingularName;
+        const decoratorManagers = [
+            new StringDecoratorManager_1.StringDecoratorManager({ isString: true, source: source, field: field }),
+            new OptionalDecoratorManager_1.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;
+    }
+    addAdditionalInverseIdsField() {
+        var _a;
+        const fieldName = `${(_a = this.field.relationModelFieldName) !== null && _a !== void 0 ? _a : this.modelName}Ids`;
+        const fieldType = "number[]";
+        const source = this.relationInverseSource;
+        const field = this.field;
+        const modelName = this.field.relationModelSingularName;
+        const decoratorManagers = [
+            new OptionalDecoratorManager_1.OptionalDecoratorManager({ isApplyOptional: true, optional: true, source: source, field: field }),
+            new ArrayDecoratorManager_1.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;
+    }
+    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;
+    }
+    addOrUpdateAdditionalField() {
+        const fieldChanges = [];
+        // 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;
+    }
+    updateAdditionalUserKeyField() {
+        var _a;
+        const userKeyFieldName = `${this.field.name}UserKey`;
+        const userKeyFieldType = typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword);
+        const source = this.source;
+        const field = this.field;
+        const decoratorManagers = [
+            new StringDecoratorManager_1.StringDecoratorManager({ isString: true, source: source, field: field }),
+            new OptionalDecoratorManager_1.OptionalDecoratorManager({ isApplyOptional: true, optional: true, source: source, field: field }),
+            // TODO pending @IsEnum(RelationFieldsCommand) 
+        ];
+        const userKeyField = (_a = this.getFieldIdentifierNode(userKeyFieldName, source)) === null || _a === void 0 ? void 0 : _a.parent;
+        //console.log(`\ncreate Dto updateAdditionalInverseCommandsField ${userKeyFieldName} called ...`);
+        if (userKeyField == null) {
+            return this.addAdditionalUserKeyField();
+        }
+        else {
+            //Update the command field
+            return this.updateFieldInternal(userKeyFieldName, userKeyFieldType, decoratorManagers, field, source);
+        }
+    }
+    updateAdditionalInverseCommandsField() {
+        var _a, _b;
+        const commandFieldName = `${(_a = this.field.relationModelFieldName) !== null && _a !== void 0 ? _a : this.modelName}Command`;
+        const commandFieldType = typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword);
+        const source = this.relationInverseSource;
+        const field = this.field;
+        const decoratorManagers = [
+            new StringDecoratorManager_1.StringDecoratorManager({ isString: true, source: source, field: field }),
+            new OptionalDecoratorManager_1.OptionalDecoratorManager({ isApplyOptional: true, optional: true, source: source, field: field }),
+            // TODO pending @IsEnum(RelationFieldsCommand) 
+        ];
+        const commandField = (_b = this.getFieldIdentifierNode(commandFieldName, source)) === null || _b === void 0 ? void 0 : _b.parent;
+        //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);
+        }
+    }
+    updateAdditionalInverseIdsField() {
+        var _a, _b;
+        const idsFieldName = `${(_a = this.field.relationModelFieldName) !== null && _a !== void 0 ? _a : this.modelName}Ids`;
+        const idsFieldType = typescript_1.default.factory.createArrayTypeNode(typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.NumberKeyword));
+        const source = this.relationInverseSource;
+        const field = this.field;
+        const decoratorManagers = [
+            new OptionalDecoratorManager_1.OptionalDecoratorManager({ isApplyOptional: true, optional: true, source: source, field: field }),
+            new ArrayDecoratorManager_1.ArrayDecoratorManager({ isArray: true, source: source, field: field })
+        ];
+        const idsField = (_b = this.getFieldIdentifierNode(idsFieldName, source)) === null || _b === void 0 ? void 0 : _b.parent;
+        //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);
+        }
+    }
+    updateAdditionalInverseField() {
+        var _a;
+        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 = (_a = this.getFieldIdentifierNode(fieldName, source)) === null || _a === void 0 ? void 0 : _a.parent;
+        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;
+        }
+    }
+    inverseFieldImport(modelName, moduleName, source) {
+        const inverseEntityImportName = `update-${(0, strings_1.dasherize)(modelName)}.dto`;
+        const inverseEntityPath = `src/${moduleName}/dtos/${inverseEntityImportName}`;
+        return (0, FieldManager_1.safeInsertImport)(source, `Update${(0, strings_1.classify)(modelName)}Dto`, inverseEntityPath);
+    }
+    removeAdditionalField() {
+        const fieldChanges = [];
+        if (this.field.relationCreateInverse) {
+            fieldChanges.push(this.removeAdditionalInverseField());
+            fieldChanges.push(this.removeAdditionalInverseIdsField());
+            fieldChanges.push(this.removeAdditionalInverseCommandsField());
+        }
+        return fieldChanges;
+    }
+    removeAdditionalInverseField() {
+        const fieldName = this.additionalFieldName();
+        const source = this.relationInverseSource;
+        return this.removeFieldFor(fieldName, source);
+    }
+    removeAdditionalInverseIdsField() {
+        var _a;
+        const fieldName = `${(_a = this.field.relationModelFieldName) !== null && _a !== void 0 ? _a : this.modelName}Ids`;
+        const source = this.relationInverseSource;
+        return this.removeFieldFor(fieldName, source);
+    }
+    removeAdditionalInverseCommandsField() {
+        var _a;
+        const fieldName = `${(_a = this.field.relationModelFieldName) !== null && _a !== void 0 ? _a : this.modelName}Command`;
+        const source = this.relationInverseSource;
+        return this.removeFieldFor(fieldName, source);
+    }
+    fieldName() {
+        return `${this.field.name}Id`;
+    }
+    additionalFieldName() {
+        var _a;
+        return (_a = this.field.relationModelFieldName) !== null && _a !== void 0 ? _a : `${this.modelName}s`;
+    }
+    isAdditionalFieldRequired() {
+        return true;
+    }
+}
+exports.ManyToOneRelationFieldManagerForDto = ManyToOneRelationFieldManagerForDto;
+//# sourceMappingURL=ManyToOneRelationFieldManagerForDto.js.map