@solidstarters/solid-code-builder 1.0.20 → 1.0.21

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

@@ -1,345 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseFieldManagerForDto = 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 ast_utils_1 = require("@schematics/angular/utility/ast-utils");
-const change_1 = require("@schematics/angular/utility/change");
-const FieldManager_1 = require("../../FieldManager");
-const ArrayDecoratorManager_1 = require("../../decorator-managers/dto/ArrayDecoratorManager");
-const BooleanDecoratorManager_1 = require("../../decorator-managers/dto/BooleanDecoratorManager");
-const DateDecoratorManager_1 = require("../../decorator-managers/dto/DateDecoratorManager");
-const DecimalDecoratorManager_1 = require("../../decorator-managers/dto/DecimalDecoratorManager");
-const IntDecoratorManager_1 = require("../../decorator-managers/dto/IntDecoratorManager");
-const JsonDecoratorManager_1 = require("../../decorator-managers/dto/JsonDecoratorManager");
-const MaxDecoratorManager_1 = require("../../decorator-managers/dto/MaxDecoratorManager");
-const MinDecoratorManager_1 = require("../../decorator-managers/dto/MinDecoratorManager");
-const NumberDecoratorManager_1 = require("../../decorator-managers/dto/NumberDecoratorManager");
-const OptionalDecoratorManager_1 = require("../../decorator-managers/dto/OptionalDecoratorManager");
-const RegexDecoratorManager_1 = require("../../decorator-managers/dto/RegexDecoratorManager");
-const RequiredDecoratorManager_1 = require("../../decorator-managers/dto/RequiredDecoratorManager");
-const StringDecoratorManager_1 = require("../../decorator-managers/dto/StringDecoratorManager");
-const TransformDecoratorManager_1 = require("../../decorator-managers/dto/TransformDecoratorManager");
-const ValidateNestedDecoratorManager_1 = require("../../decorator-managers/dto/ValidateNestedDecoratorManager");
-const BigIntDecoratorManager_1 = require("../../decorator-managers/dto/BigIntDecoratorManager");
-const MaxLengthDecoratorManager_1 = require("../../decorator-managers/dto/MaxLengthDecoratorManager");
-const MinLengthDecoratorManager_1 = require("../../decorator-managers/dto/MinLengthDecoratorManager");
-// This class manages the field generation for the DTOs
-// It adds validation decorators to the fields
-// The validation decorators added use the class-validator library
-class BaseFieldManagerForDto {
-    constructor(tree, moduleName, modelName, field, options) {
-        this.moduleName = moduleName;
-        this.modelName = modelName;
-        this.field = field;
-        this.options = options;
-        const sourceFileName = (options.sourceType === FieldManager_1.DtoSourceType.Create) ? `create-${(0, strings_1.dasherize)(modelName)}.dto.ts` : `update-${(0, strings_1.dasherize)(modelName)}.dto.ts`;
-        const sourcePath = `src/${(0, strings_1.dasherize)(moduleName)}/dtos/${sourceFileName}`;
-        this.source = (0, FieldManager_1.createSourceFile)(tree, sourcePath);
-        this.decoratorManagers = this.getFieldDecoratorManagers(this.field, this.source, FieldManager_1.DecoratorType.Max, FieldManager_1.DecoratorType.Min, FieldManager_1.DecoratorType.MinLength, FieldManager_1.DecoratorType.MaxLength, FieldManager_1.DecoratorType.Required, FieldManager_1.DecoratorType.Optional, FieldManager_1.DecoratorType.Regex, FieldManager_1.DecoratorType.Number, FieldManager_1.DecoratorType.Int, FieldManager_1.DecoratorType.Decimal, FieldManager_1.DecoratorType.String, FieldManager_1.DecoratorType.Date, FieldManager_1.DecoratorType.Boolean, FieldManager_1.DecoratorType.Json);
-    }
-    removeField() {
-        const fieldChanges = [];
-        console.log(`Dto removeField ${this.fieldName()} called ...`);
-        fieldChanges.push(this.removeFieldFor(this.fieldName(), this.source));
-        if (this.isAdditionalFieldRequired()) {
-            fieldChanges.push(...this.removeAdditionalField());
-        }
-        return fieldChanges;
-    }
-    fieldName() {
-        return this.field.name;
-    }
-    removeFieldFor(fieldName, fieldSource) {
-        const fieldIdentifierNode = this.getFieldIdentifierNode(fieldName, fieldSource);
-        if (fieldIdentifierNode == null) {
-            // throw new Error(`Could not remove field. Field: ${fieldName} is missing in entity ${classify(this.modelName)}.`);
-            return {
-                filePath: this.source.fileName,
-                field: this.field,
-                changes: [],
-            };
-        }
-        const propertyDeclarationNode = fieldIdentifierNode.parent;
-        return {
-            filePath: fieldSource.fileName,
-            field: this.field,
-            changes: [
-                new FieldManager_1.RemoveChangeSSS(fieldSource.fileName, propertyDeclarationNode.pos, propertyDeclarationNode.getFullText()),
-            ],
-        };
-    }
-    getFieldIdentifierNode(fieldName, fieldSource) {
-        return (0, ast_utils_1.findNodes)(fieldSource, typescript_1.default.SyntaxKind.Identifier)
-            .filter((node) => node.getText() === fieldName)
-            .filter((node) => (node === null || node === void 0 ? void 0 : node.parent) && typescript_1.default.isPropertyDeclaration(node === null || node === void 0 ? void 0 : node.parent))
-            .pop();
-    }
-    isFieldPresent(fieldName, fieldSource) {
-        return this.getFieldIdentifierNode(fieldName, fieldSource) != null;
-    }
-    addFieldInternal(fieldName, fieldType, decoratorManagers, field, modelName, source) {
-        //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)) {
-            return {
-                filePath: source.fileName,
-                field: field,
-                changes: [],
-            };
-            // throw new Error(
-            //   `Field: ${fieldName} already exists in entity ${classify(modelName)}. Use the updateField() method to modify the field`
-            // );
-        }
-        const fieldSourceLines = [];
-        const changes = [];
-        //Add the dto field declaration
-        let dtoPropertyLine = this.buildPropertyLine(fieldName, fieldType, field.defaultValue);
-        fieldSourceLines.push(dtoPropertyLine);
-        //Add the decorators to the field declaration
-        const builderChanges = [];
-        builderChanges.push(...this.applyBuildDecoratorTransformations(...decoratorManagers.reverse()));
-        // Capture the changes and field source lines
-        builderChanges.forEach((builderChange) => {
-            changes.push(...builderChange.changes);
-            fieldSourceLines.push(...builderChange.fieldSourceLines);
-        });
-        // Create the field definition changes
-        // const classNode = findNodes(source, ts.SyntaxKind.ClassDeclaration)[0];
-        const className = (this.options.sourceType === FieldManager_1.DtoSourceType.Create) ? `Create${(0, strings_1.classify)(modelName)}Dto` : `Update${(0, strings_1.classify)(modelName)}Dto`;
-        const classNode = (0, FieldManager_1.getClassNode)(className, source);
-        if (!classNode) {
-            throw new Error(`Class ${className} not found in file ${source.fileName}`);
-        }
-        const fieldDefinition = `\n${fieldSourceLines.reverse().join('\n')}\n`;
-        changes.push(new change_1.InsertChange(source.fileName, classNode.end - 1, fieldDefinition));
-        return {
-            filePath: source.fileName,
-            field: field,
-            changes: changes,
-        };
-    }
-    buildPropertyLine(fieldName, fieldType, defaultConfigValue) {
-        var _a, _b;
-        let entityPropertyLine = `${fieldName}: ${fieldType}`;
-        const defaultValue = (_b = (_a = this.defaultValueInitializer(defaultConfigValue)) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : null;
-        if (defaultValue) {
-            entityPropertyLine += ` = ${defaultValue}`;
-        }
-        entityPropertyLine += ';';
-        return entityPropertyLine;
-    }
-    addField() {
-        const fieldChanges = [];
-        const fieldName = this.fieldName();
-        const fieldType = this.fieldType().text;
-        const source = this.source;
-        const field = this.field;
-        const modelName = this.modelName;
-        const decoratorManagers = this.decoratorManagers;
-        fieldChanges.push(this.addFieldInternal(fieldName, fieldType, decoratorManagers, field, modelName, source));
-        if (this.isAdditionalFieldRequired()) {
-            // Get the related field property declaration node
-            fieldChanges.push(...this.addAdditionalField());
-        }
-        return fieldChanges;
-    }
-    updateFieldInternal(fieldName, fieldType, decoratorManagers, field, source) {
-        var _a;
-        const changes = [];
-        // Get the field property declaration node
-        const fieldPropertyDeclarationNode = (_a = this.getFieldIdentifierNode(fieldName, source)) === null || _a === void 0 ? void 0 : _a.parent;
-        // FIXME Handle the imports related to the updated field type
-        // Update the entity property declaration type
-        let updatedPropertyDeclarationNode = this.updateFieldType(fieldPropertyDeclarationNode, fieldType);
-        // Apply the decorator transformations  to the field property declaration node
-        const [updatedPropertyDeclarationNodeTransformed, decoratorChanges] = this.applyUpdateDecoratorTransformations(updatedPropertyDeclarationNode, ...decoratorManagers);
-        updatedPropertyDeclarationNode = updatedPropertyDeclarationNodeTransformed;
-        changes.push(...decoratorChanges);
-        changes.push(...this.calculateReplaceChanges(this.printNode(updatedPropertyDeclarationNode, source), fieldPropertyDeclarationNode, source));
-        return {
-            filePath: source.fileName,
-            field: field,
-            changes: changes,
-        };
-    }
-    updateField() {
-        const fieldChanges = [];
-        console.log(`\ncreate Dto updateField ${this.fieldName()} called ...`);
-        const fieldName = this.fieldName();
-        const fieldType = this.fieldType().node(this.field);
-        const source = this.source;
-        const field = this.field;
-        const decoratorManagers = this.decoratorManagers;
-        //Validate if field exists
-        if (!this.isFieldPresent(this.fieldName(), this.source)) {
-            return this.addField();
-        }
-        const fieldChange = this.updateFieldInternal(fieldName, fieldType, decoratorManagers, field, source);
-        fieldChanges.push(fieldChange);
-        if (this.isAdditionalFieldRequired()) {
-            // Get the related field property declaration node
-            fieldChanges.push(...this.addOrUpdateAdditionalField()); // TODO This needs to be refactored and renamed to updateAdditionalField, since it is confusing
-        }
-        else {
-            // fieldChanges.push(this.removeAdditionalField()); //FIXME temporary fix, to check update module command
-        }
-        return fieldChanges;
-    }
-    addAdditionalField() {
-        throw new Error(`addAdditionalField method not implemented for field ${this.fieldName()} of type ${this.field.type}`);
-    }
-    addOrUpdateAdditionalField() {
-        throw new Error(`addOrUpdateAdditionalField method not implemented for field ${this.fieldName()} of type ${this.field.type}`);
-    }
-    removeAdditionalField() {
-        return [{
-                filePath: this.source.fileName,
-                field: this.field,
-                changes: [],
-            }];
-    }
-    updateFieldType(fieldPropertyDeclarationNode, newTypeNode) {
-        // console.log(
-        //   `\nEntity updateFieldType ${this.fieldName()} called ... with existing field type: ${fieldPropertyDeclarationNode.type?.getText()}`,
-        // );
-        // const newTypeNode: ts.TypeNode = this.fieldType().node(this.field);
-        const updatedPropertyDeclaration = typescript_1.default.factory.updatePropertyDeclaration(fieldPropertyDeclarationNode, fieldPropertyDeclarationNode.modifiers, fieldPropertyDeclarationNode.name, fieldPropertyDeclarationNode.questionToken, newTypeNode, // Replace with new type node
-        fieldPropertyDeclarationNode.initializer);
-        return updatedPropertyDeclaration;
-    }
-    isBigInt() {
-        return false;
-    }
-    ;
-    isApplyMinLength() {
-        return false;
-    }
-    isApplyMaxLength() {
-        return false;
-    }
-    applyUpdateDecoratorTransformations(fieldPropertyDeclarationNode, ...transformers) {
-        let updatedPropertyDeclarationNode = fieldPropertyDeclarationNode;
-        const changes = [];
-        transformers.forEach(updateTransformation());
-        return [updatedPropertyDeclarationNode, changes];
-        function updateTransformation() {
-            return transformer => {
-                transformer.setFieldNode(updatedPropertyDeclarationNode);
-                try {
-                    const [updatedPropertyDeclaration, updateChanges] = transformer.updateDecorator();
-                    updatedPropertyDeclarationNode = updatedPropertyDeclaration;
-                    changes.push(...updateChanges);
-                }
-                catch (error) {
-                    // console.log(`Error updating decorator for ${transformer.decoratorName()} with message: ${error.message}`);
-                    throw error;
-                }
-            };
-        }
-    }
-    applyBuildDecoratorTransformations(...transformers) {
-        const partialFieldChanges = [];
-        transformers.forEach(buildTransformation());
-        return partialFieldChanges;
-        function buildTransformation() {
-            return transformer => {
-                if (!transformer.isApplyDecorator())
-                    return;
-                try {
-                    partialFieldChanges.push(transformer.buildDecorator());
-                }
-                catch (error) {
-                    // console.log(`Error building decorator for ${transformer.decoratorName()} with message: ${error.message}`);
-                    throw error;
-                }
-            };
-        }
-    }
-    calculateReplaceChanges(updatedPropertyDeclarationNodeText, fieldPropertyDeclarationNode, source) {
-        const changes = [];
-        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`);
-            const replaceChange = new FieldManager_1.ReplaceChangeSSS(source.fileName, fieldPropertyDeclarationNode.pos, fieldPropertyDeclarationNode.getFullText(), `\n\n${updatedPropertyDeclarationNodeText}`);
-            changes.push(replaceChange);
-        }
-        return changes;
-    }
-    printNode(updatedPropertyDeclarationNode, nodeSource) {
-        const printer = typescript_1.default.createPrinter({
-            newLine: typescript_1.default.NewLineKind.LineFeed,
-            removeComments: false,
-            omitTrailingSemicolon: false,
-        });
-        const updatedPropertyDeclarationNodeText = printer.printNode(typescript_1.default.EmitHint.Unspecified, updatedPropertyDeclarationNode, nodeSource);
-        return updatedPropertyDeclarationNodeText;
-    }
-    isAdditionalFieldRequired() {
-        return false;
-    }
-    //FIXME: This code is not useful, better initialize the decorators using the constructor, for now
-    getFieldDecoratorManagers(field, source, ...decoratorTypes) {
-        return decoratorTypes.map((decoratorType) => {
-            switch (decoratorType) {
-                case FieldManager_1.DecoratorType.Max:
-                    return new MaxDecoratorManager_1.MaxDecoratorManager({ isApplyMax: this.isApplyMax(), max: field.max, source: source, field: field });
-                case FieldManager_1.DecoratorType.Min:
-                    return new MinDecoratorManager_1.MinDecoratorManager({ isApplyMin: this.isApplyMin(), min: field.min, source: source, field: field });
-                case FieldManager_1.DecoratorType.MinLength:
-                    return new MinLengthDecoratorManager_1.MinLengthDecoratorManager({ isApplyMinLength: this.isApplyMinLength(), length: field.min, source: source, field: field });
-                case FieldManager_1.DecoratorType.MaxLength:
-                    return new MaxLengthDecoratorManager_1.MaxLengthDecoratorManager({ isApplyMaxLength: this.isApplyMaxLength(), length: field.max, source: source, field: field });
-                case FieldManager_1.DecoratorType.Required:
-                    return new RequiredDecoratorManager_1.RequiredDecoratorManager({ isApplyRequired: true, required: field.required, source: source, field: field });
-                case FieldManager_1.DecoratorType.Optional:
-                    return new OptionalDecoratorManager_1.OptionalDecoratorManager({ isApplyOptional: true, optional: (this.options.sourceType === FieldManager_1.DtoSourceType.Update || !field.required), source: source, field: field });
-                case FieldManager_1.DecoratorType.Regex:
-                    return new RegexDecoratorManager_1.RegexDecoratorManager({ isApplyRegex: this.isApplyRegex(), regexPattern: field.regexPattern, source: source, field: field });
-                case FieldManager_1.DecoratorType.Number:
-                    return new NumberDecoratorManager_1.NumberDecoratorManager({ isNumber: this.isNumber(), source: source, field: field });
-                case FieldManager_1.DecoratorType.String:
-                    return new StringDecoratorManager_1.StringDecoratorManager({ isString: this.isString(), source: source, field: field });
-                case FieldManager_1.DecoratorType.Int:
-                    return new IntDecoratorManager_1.IntDecoratorManager({ isInt: this.isInt(), source: source, field: field });
-                case FieldManager_1.DecoratorType.Decimal:
-                    return new DecimalDecoratorManager_1.DecimalDecoratorManager({ isDecimal: this.isDecimal(), source: source, field: field });
-                case FieldManager_1.DecoratorType.BigInt:
-                    return new BigIntDecoratorManager_1.BigIntDecoratorManager({ isBigInt: this.isBigInt(), source: source, field: field });
-                case FieldManager_1.DecoratorType.Date:
-                    return new DateDecoratorManager_1.DateDecoratorManager({ isDate: this.isDate(), source: source, field: field });
-                case FieldManager_1.DecoratorType.Boolean:
-                    return new BooleanDecoratorManager_1.BooleanDecoratorManager({ isBoolean: this.isBoolean(), source: source, field: field });
-                case FieldManager_1.DecoratorType.Json:
-                    return new JsonDecoratorManager_1.JsonDecoratorManager({ isJson: this.isJson(), source: source, field: field });
-                case FieldManager_1.DecoratorType.Transform:
-                    return new TransformDecoratorManager_1.TransformDecoratorManager({ isTransform: true, type: this.fieldType().text.replace("[]", ""), source: source, field: field });
-                case FieldManager_1.DecoratorType.Array:
-                    return new ArrayDecoratorManager_1.ArrayDecoratorManager({ isArray: true, source: source, field: field });
-                case FieldManager_1.DecoratorType.ValidateNested:
-                    return new ValidateNestedDecoratorManager_1.ValidateNestedDecoratorManager({ isValidateNested: true, source: source, field: field });
-            }
-        });
-    }
-    parseDefaultValue(defaultValueConfig) {
-        if (!defaultValueConfig)
-            return null;
-        return defaultValueConfig;
-    }
-    defaultValueInitializer(defaultValueConfig) {
-        const defaultValue = this.parseDefaultValue(defaultValueConfig);
-        if (!defaultValue)
-            return null;
-        return {
-            value: defaultValue,
-            text: `"${defaultValue.toString()}"`,
-            expression: typescript_1.default.factory.createStringLiteral(defaultValue.toString())
-        };
-    }
-}
-exports.BaseFieldManagerForDto = BaseFieldManagerForDto;
-//# sourceMappingURL=BaseFieldManagerForDto.js.map