@solidstarters/solid-code-builder 1.0.20 → 1.0.21

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

@@ -1,236 +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.IsBigInt = exports.safeInsertImport = exports.ManagerForDtoOptions = exports.DtoSourceType = exports.RelationType = exports.getClassExportKeywordNode = exports.getClassNode = exports.createSourceFile = exports.getFieldHandler = exports.ReplaceChangeSSS = exports.RemoveChangeSSS = exports.PartialAddFieldChange = exports.DeleteType = exports.DecoratorType = exports.UUID_REGEX = exports.MAX_EMAIL_LENGTH = void 0;
-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 class_validator_1 = require("class-validator");
-const BigIntFieldHandler_1 = require("./field-managers/bigint/BigIntFieldHandler");
-const BooleanFieldHandler_1 = require("./field-managers/boolean/BooleanFieldHandler");
-const ComputedFieldHandler_1 = require("./field-managers/computed/ComputedFieldHandler");
-const DateFieldHandler_1 = require("./field-managers/date/DateFieldHandler");
-const DecimalFieldHandler_1 = require("./field-managers/decimal/DecimalFieldHandler");
-const EmailFieldHandler_1 = require("./field-managers/email/EmailFieldHandler");
-const IntFieldHandler_1 = require("./field-managers/int/IntFieldHandler");
-const JsonFieldHandler_1 = require("./field-managers/json/JsonFieldHandler");
-const LongTextFieldHandler_1 = require("./field-managers/long-text/LongTextFieldHandler");
-const NoOpsFieldHandler_1 = require("./field-managers/no-ops/NoOpsFieldHandler");
-const PasswordFieldHandler_1 = require("./field-managers/password/PasswordFieldHandler");
-const ManyToManyRelationFieldHandler_1 = require("./field-managers/relation/ManyToManyRelationFieldHandler");
-const ManyToOneRelationFieldHandler_1 = require("./field-managers/relation/ManyToOneRelationFieldHandler");
-const RichTextFieldHandler_1 = require("./field-managers/rich-text/RichTextFieldHandler");
-const ShortTextFieldHandler_1 = require("./field-managers/short-text/ShortTextFieldHandler");
-const UUIDFieldHandler_1 = require("./field-managers/uuid/UUIDFieldHandler");
-exports.MAX_EMAIL_LENGTH = 254;
-exports.UUID_REGEX = `^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$`;
-var SolidFieldType;
-(function (SolidFieldType) {
-    // numeric types
-    SolidFieldType["int"] = "int";
-    SolidFieldType["bigint"] = "bigint";
-    // float = 'float',
-    // double = 'double',
-    SolidFieldType["decimal"] = "decimal";
-    // text types
-    SolidFieldType["shortText"] = "shortText";
-    SolidFieldType["longtext"] = "longText";
-    SolidFieldType["richText"] = "richText";
-    SolidFieldType["json"] = "json";
-    // boolean types
-    SolidFieldType["boolean"] = "boolean";
-    // date
-    SolidFieldType["date"] = "date";
-    SolidFieldType["datetime"] = "datetime";
-    SolidFieldType["time"] = "time";
-    // relation
-    SolidFieldType["relation"] = "relation";
-    // media
-    SolidFieldType["mediaSingle"] = "mediaSingle";
-    SolidFieldType["mediaMultiple"] = "mediaMultiple";
-    SolidFieldType["email"] = "email";
-    SolidFieldType["password"] = "password";
-    // selection
-    SolidFieldType["selectionStatic"] = "selectionStatic";
-    SolidFieldType["selectionDynamic"] = "selectionDynamic";
-    SolidFieldType["uuid"] = "uuid";
-    SolidFieldType["computed"] = "computed";
-})(SolidFieldType || (SolidFieldType = {}));
-var DecoratorType;
-(function (DecoratorType) {
-    DecoratorType["Max"] = "max";
-    DecoratorType["Min"] = "min";
-    DecoratorType["Required"] = "required";
-    DecoratorType["Optional"] = "optional";
-    DecoratorType["Regex"] = "regex";
-    DecoratorType["Number"] = "number";
-    DecoratorType["String"] = "string";
-    DecoratorType["Int"] = "int";
-    DecoratorType["Decimal"] = "decimal";
-    DecoratorType["Date"] = "date";
-    DecoratorType["Boolean"] = "boolean";
-    DecoratorType["Json"] = "json";
-    DecoratorType["Transform"] = "transform";
-    DecoratorType["Array"] = "array";
-    DecoratorType["ValidateNested"] = "validateNested";
-    DecoratorType["BigInt"] = "bigint";
-    DecoratorType["MinLength"] = "minLength";
-    DecoratorType["MaxLength"] = "maxLength";
-})(DecoratorType || (exports.DecoratorType = DecoratorType = {}));
-var DeleteType;
-(function (DeleteType) {
-    DeleteType["CASCADE"] = "CASCADE";
-    DeleteType["RESTRICT"] = "RESTRICT";
-    DeleteType["SET_NULL"] = "SET_NULL";
-    DeleteType["SET_DEFAULT"] = "SET_DEFAULT";
-})(DeleteType || (exports.DeleteType = DeleteType = {}));
-class PartialAddFieldChange {
-    constructor() {
-        this.changes = [];
-        this.fieldSourceLines = [];
-    }
-}
-exports.PartialAddFieldChange = PartialAddFieldChange;
-// export class PartialUpdateFieldChange implements FieldChange {
-//   filePath: string;
-//   field: any;
-//   changes: Change[] = [];
-//   updatedPropertyNode: PropertyDeclaration;
-// }
-class RemoveChangeSSS extends change_1.RemoveChange {
-    constructor(path, pos, toRemove) {
-        super(path, pos, toRemove);
-        this.removePosition = pos;
-    }
-}
-exports.RemoveChangeSSS = RemoveChangeSSS;
-class ReplaceChangeSSS extends change_1.ReplaceChange {
-    constructor(path, pos, oldText, newText) {
-        super(path, pos, oldText, newText);
-        this.replacePosition = pos;
-    }
-}
-exports.ReplaceChangeSSS = ReplaceChangeSSS;
-function getFieldHandler(tree, moduleName, modelName, field) {
-    // console.log('field', field);
-    switch (field.type) {
-        case SolidFieldType.shortText:
-        case SolidFieldType.selectionStatic:
-        case SolidFieldType.selectionDynamic:
-            if (field.selectionValueType === "int") {
-                return new IntFieldHandler_1.IntFieldHandler(tree, moduleName, modelName, field);
-            }
-            return new ShortTextFieldHandler_1.ShortTextFieldHandler(tree, moduleName, modelName, field);
-        case SolidFieldType.longtext:
-            return new LongTextFieldHandler_1.LongTextFieldHandler(tree, moduleName, modelName, field);
-        case SolidFieldType.richText:
-            return new RichTextFieldHandler_1.RichTextFieldHandler(tree, moduleName, modelName, field);
-        case SolidFieldType.json:
-            return new JsonFieldHandler_1.JsonFieldHandler(tree, moduleName, modelName, field);
-        case SolidFieldType.int:
-            return new IntFieldHandler_1.IntFieldHandler(tree, moduleName, modelName, field);
-        case SolidFieldType.decimal:
-            return new DecimalFieldHandler_1.DecimalFieldHandler(tree, moduleName, modelName, field);
-        case SolidFieldType.bigint:
-            return new BigIntFieldHandler_1.BigIntFieldHandler(tree, moduleName, modelName, field);
-        case SolidFieldType.boolean:
-            return new BooleanFieldHandler_1.BooleanFieldHandler(tree, moduleName, modelName, field);
-        case SolidFieldType.email:
-            return new EmailFieldHandler_1.EmailFieldHandler(tree, moduleName, modelName, field);
-        case SolidFieldType.password:
-            return new PasswordFieldHandler_1.PasswordFieldHandler(tree, moduleName, modelName, field);
-        case SolidFieldType.date:
-        case SolidFieldType.datetime:
-        case SolidFieldType.time:
-            return new DateFieldHandler_1.DateFieldHandler(tree, moduleName, modelName, field);
-        case SolidFieldType.relation:
-            if (field.relationType === RelationType.ManyToMany) {
-                return new ManyToManyRelationFieldHandler_1.ManyToManyRelationFieldHandler(tree, moduleName, modelName, field);
-            }
-            else {
-                return new ManyToOneRelationFieldHandler_1.ManyToOneRelationFieldHandler(tree, moduleName, modelName, field);
-            }
-        case SolidFieldType.mediaSingle:
-        case SolidFieldType.mediaMultiple:
-            return new NoOpsFieldHandler_1.NoOpsFieldHandler(tree, moduleName, modelName, field);
-        case SolidFieldType.uuid:
-            return new UUIDFieldHandler_1.UUIDFieldHandler(tree, moduleName, modelName, field);
-        case SolidFieldType.computed:
-            return new ComputedFieldHandler_1.ComputedFieldHandler(tree, moduleName, modelName, field);
-        default:
-            console.log(`Field ${field.name} of type ${field.type} not supported yet`);
-            return new NoOpsFieldHandler_1.NoOpsFieldHandler(tree, moduleName, modelName, field);
-    }
-}
-exports.getFieldHandler = getFieldHandler;
-function createSourceFile(tree, filePath) {
-    return typescript_1.default.createSourceFile(filePath, tree.readText(filePath), typescript_1.default.ScriptTarget.Latest, true);
-}
-exports.createSourceFile = createSourceFile;
-function getClassNode(className, source) {
-    const classNodes = (0, ast_utils_1.findNodes)(source, typescript_1.default.SyntaxKind.ClassDeclaration);
-    return classNodes.find(node => node.name && node.name.text === className);
-}
-exports.getClassNode = getClassNode;
-function getClassExportKeywordNode(className, sourceFile) {
-    var _a;
-    const classNode = getClassNode(className, sourceFile);
-    if (!classNode) {
-        throw new Error(`Class "${className}" not found`);
-    }
-    // Find the `export` modifier
-    const exportModifier = (_a = classNode.modifiers) === null || _a === void 0 ? void 0 : _a.find((modifier) => modifier.kind === typescript_1.default.SyntaxKind.ExportKeyword
-    // (modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword
-    );
-    return exportModifier;
-}
-exports.getClassExportKeywordNode = getClassExportKeywordNode;
-;
-var RelationType;
-(function (RelationType) {
-    RelationType["ManyToOne"] = "many-to-one";
-    RelationType["ManyToMany"] = "many-to-many";
-})(RelationType || (exports.RelationType = RelationType = {}));
-var DtoSourceType;
-(function (DtoSourceType) {
-    DtoSourceType["Create"] = "create";
-    DtoSourceType["Update"] = "update";
-})(DtoSourceType || (exports.DtoSourceType = DtoSourceType = {}));
-class ManagerForDtoOptions {
-    constructor(sourceType) {
-        this.sourceType = sourceType;
-    }
-}
-exports.ManagerForDtoOptions = ManagerForDtoOptions;
-// insertImport(this.source, this.source.fileName, `Update${classify(this.field.relationModelSingularName)}Dto`, relatedEntityPath);
-function safeInsertImport(source, symbolName, importFileName) {
-    // Check if in current source, there exists a class with the same symbolName
-    if (!getClassNode(symbolName, source)) {
-        return (0, ast_utils_1.insertImport)(source, source.fileName, symbolName, importFileName);
-    }
-    return new change_1.NoopChange();
-}
-exports.safeInsertImport = safeInsertImport;
-// Register a custom decorator
-function IsBigInt(validationOptions) {
-    return function (object, propertyName) {
-        (0, class_validator_1.registerDecorator)({
-            name: 'isBigInt',
-            target: object.constructor,
-            propertyName: propertyName,
-            options: validationOptions,
-            validator: {
-                validate(value, _args) {
-                    return typeof value === 'bigint';
-                },
-                defaultMessage(args) {
-                    return `${args.property} must be a BigInt`;
-                },
-            },
-        });
-    };
-}
-exports.IsBigInt = IsBigInt;
-//# sourceMappingURL=FieldManager.js.map

package/src/code-builder/lib/field/decorator-managers/dto/ArrayDecoratorManager.js

@@ -1,107 +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.ArrayDecoratorManager = void 0;
-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");
-class ArrayDecoratorManager {
-    constructor(options, fieldNode) {
-        this.options = options;
-        this.fieldNode = fieldNode;
-    }
-    isApplyDecorator() {
-        return this.options.isArray;
-    }
-    buildDecorator() {
-        const fieldSourceLines = [];
-        const changes = [];
-        fieldSourceLines.push(`@${this.decoratorName()}()`);
-        changes.push(...this.decoratorImports());
-        return {
-            filePath: this.options.source.fileName,
-            field: this.options.field,
-            changes: changes,
-            fieldSourceLines: fieldSourceLines,
-        };
-    }
-    setFieldNode(fieldNode) {
-        this.fieldNode = fieldNode;
-    }
-    decoratorName() {
-        return 'IsArray';
-    }
-    decoratorImports() {
-        return [(0, ast_utils_1.insertImport)(this.options.source, this.options.source.fileName, this.decoratorName(), 'class-validator')];
-    }
-    updateDecorator() {
-        if (!this.fieldNode)
-            throw new Error(`Field node is required for updating the ${this.decoratorName()} decorator`);
-        let newModifiers = [];
-        let existingModifiers = this.fieldNode.modifiers;
-        // Check if the field has an IsArray decorator.
-        const existingDecorator = this.findDecorator(this.decoratorName(), existingModifiers);
-        //Remove the  decorator if the  decorator exists
-        //TODO probably this too can be done in a lesser intrusive way i.e update everything instead of removing and adding
-        newModifiers = [...this.filterNonDecorators(existingModifiers), ...this.filterOtherDecorators(this.decoratorName(), existingModifiers)];
-        //Add the  decorator, if it is required
-        const changes = [];
-        if (this.isApplyDecorator()) {
-            newModifiers = [...newModifiers, this.createDecorator(existingDecorator)];
-            changes.push(...this.decoratorImports());
-        }
-        const updatedProperty = typescript_1.default.factory.updatePropertyDeclaration(this.fieldNode, newModifiers, //Replace with new modifiers
-        this.fieldNode.name, this.fieldNode.questionToken, this.fieldNode.type, this.fieldNode.initializer);
-        return [updatedProperty, changes];
-    }
-    createDecorator(existingDecorator) {
-        // Capture the existing isArray decorator options
-        const validationOptions = this.existingValidationOptions(existingDecorator);
-        // Re-create the isArray decorator with the existing isArray decorator options
-        const decoratorIdentifier = typescript_1.default.factory.createIdentifier(this.decoratorName());
-        const argumentsArray = this.createDecoratorArguments(validationOptions);
-        const call = typescript_1.default.factory.createCallExpression(decoratorIdentifier, undefined, argumentsArray);
-        return typescript_1.default.factory.createDecorator(call);
-    }
-    createDecoratorArguments(validationOptions) {
-        const argumentsArray = [];
-        if (validationOptions.length > 0) {
-            const validationOptionsObjectLiteral = typescript_1.default.factory.createObjectLiteralExpression(validationOptions);
-            argumentsArray.push(validationOptionsObjectLiteral);
-        }
-        return argumentsArray;
-    }
-    existingValidationOptions(existingDecorator) {
-        const validationOptions = [];
-        if (existingDecorator !== undefined) {
-            //Pre-set the isArray options from the existing IsArray decorator
-            const existingCallExpression = existingDecorator.expression;
-            // Check if  call expression has at least 1 argument
-            if (existingCallExpression.arguments.length > 0) {
-                if (!typescript_1.default.isObjectLiteralExpression(existingCallExpression.arguments[0])) {
-                    throw new Error('IsArray decorator 1st argument must be an object literal containing the validation options');
-                }
-                const existingObjectLiteralExpression = existingCallExpression.arguments[0];
-                validationOptions.push(...existingObjectLiteralExpression.properties);
-            }
-        }
-        return validationOptions;
-    }
-    findDecorator(name, existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator)).map(m => m).filter(m => this.containsIdentifierName(m, name)).pop() : undefined;
-    }
-    filterOtherDecorators(name, existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator)).map(m => m).filter(m => !this.containsIdentifierName(m, name)) : [];
-    }
-    filterNonDecorators(existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind !== typescript_1.default.SyntaxKind.Decorator)).map(m => m) : [];
-    }
-    containsIdentifierName(m, identifierName) {
-        const callExpression = m.expression;
-        const identifier = callExpression.expression;
-        return identifier.text === identifierName;
-    }
-}
-exports.ArrayDecoratorManager = ArrayDecoratorManager;
-//# sourceMappingURL=ArrayDecoratorManager.js.map

package/src/code-builder/lib/field/decorator-managers/dto/BigIntDecoratorManager.js

@@ -1,100 +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.BigIntDecoratorManager = void 0;
-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");
-class BigIntDecoratorManager {
-    constructor(options, fieldNode) {
-        this.options = options;
-        this.fieldNode = fieldNode;
-    }
-    isApplyDecorator() {
-        return this.options.isBigInt;
-    }
-    buildDecorator() {
-        const fieldSourceLines = [];
-        const changes = [];
-        fieldSourceLines.push(`@${this.decoratorName()}()`);
-        changes.push(...this.decoratorImports());
-        return {
-            filePath: this.options.source.fileName,
-            field: this.options.field,
-            changes: changes,
-            fieldSourceLines: fieldSourceLines,
-        };
-    }
-    setFieldNode(fieldNode) {
-        this.fieldNode = fieldNode;
-    }
-    decoratorName() {
-        return 'IsBigInt';
-    }
-    decoratorImports() {
-        return [(0, ast_utils_1.insertImport)(this.options.source, this.options.source.fileName, this.decoratorName(), '../../FieldManager')];
-    }
-    updateDecorator() {
-        if (!this.fieldNode)
-            throw new Error(`Field node is required for updating the ${this.decoratorName()} decorator`);
-        let newModifiers = [];
-        let existingModifiers = this.fieldNode.modifiers;
-        // Check if the field has an Length decorator.
-        //@ts-ignore
-        const existingDecorator = this.findDecorator(this.decoratorName(), existingModifiers);
-        //Remove the column decorator if the column decorator exists
-        //TODO probably this too can be done in a lesser intrusive way i.e update everything instead of removing and adding
-        newModifiers = [...this.filterNonDecorators(existingModifiers), ...this.filterOtherDecorators(this.decoratorName(), existingModifiers)];
-        //Add the column decorator if column decorator is required  
-        const changes = [];
-        if (this.isApplyDecorator()) {
-            newModifiers = [...newModifiers, this.createDecorator(existingDecorator)];
-            changes.push(...this.decoratorImports());
-        }
-        const updatedProperty = typescript_1.default.factory.updatePropertyDeclaration(this.fieldNode, newModifiers, //Replace with new modifiers
-        this.fieldNode.name, this.fieldNode.questionToken, this.fieldNode.type, this.fieldNode.initializer);
-        return [updatedProperty, changes];
-    }
-    createDecorator(existingDecorator) {
-        // Capture the existing column decorator options
-        const validationOptions = [];
-        if (existingDecorator !== undefined) {
-            // Pre-set the column options from the existing column decorator
-            const existingCallExpression = existingDecorator.expression;
-            // Check if  call expression has at least 1 arguments
-            if (existingCallExpression.arguments.length > 0) {
-                if (!typescript_1.default.isObjectLiteralExpression(existingCallExpression.arguments[0])) {
-                    throw new Error(`${this.decoratorName()} decorator 1rd argument must be an object literal containing the validation options`);
-                }
-                const existingObjectLiteralExpression = existingCallExpression.arguments[0];
-                validationOptions.push(...existingObjectLiteralExpression.properties);
-            }
-        }
-        // Re-create the column decorator with the merged column decorator options
-        const decoratorIdentifier = typescript_1.default.factory.createIdentifier(this.decoratorName());
-        const argumentsArray = [];
-        if (validationOptions.length > 0) {
-            const validationOptionsObjectLiteral = typescript_1.default.factory.createObjectLiteralExpression(validationOptions);
-            argumentsArray.push(validationOptionsObjectLiteral);
-        }
-        const call = typescript_1.default.factory.createCallExpression(decoratorIdentifier, undefined, argumentsArray);
-        return typescript_1.default.factory.createDecorator(call);
-    }
-    findDecorator(name, existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator)).map(m => m).filter(m => this.containsIdentifierName(m, name)).pop() : undefined;
-    }
-    filterOtherDecorators(name, existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator)).map(m => m).filter(m => !this.containsIdentifierName(m, name)) : [];
-    }
-    filterNonDecorators(existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind !== typescript_1.default.SyntaxKind.Decorator)).map(m => m) : [];
-    }
-    containsIdentifierName(m, identifierName) {
-        const callExpression = m.expression;
-        const identifier = callExpression.expression;
-        return identifier.text === identifierName;
-    }
-}
-exports.BigIntDecoratorManager = BigIntDecoratorManager;
-//# sourceMappingURL=BigIntDecoratorManager.js.map

package/src/code-builder/lib/field/decorator-managers/dto/BooleanDecoratorManager.js

@@ -1,102 +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.BooleanDecoratorManager = void 0;
-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");
-class BooleanDecoratorManager {
-    constructor(options, fieldNode) {
-        this.options = options;
-        this.fieldNode = fieldNode;
-    }
-    isApplyDecorator() {
-        return this.options.isBoolean;
-    }
-    buildDecorator() {
-        const fieldSourceLines = [];
-        const changes = [];
-        fieldSourceLines.push(`@${this.decoratorName()}()`);
-        changes.push(...this.decoratorImports());
-        return {
-            filePath: this.options.source.fileName,
-            field: this.options.field,
-            changes: changes,
-            fieldSourceLines: fieldSourceLines,
-        };
-    }
-    setFieldNode(fieldNode) {
-        this.fieldNode = fieldNode;
-    }
-    decoratorName() {
-        return 'IsBoolean';
-    }
-    decoratorImports() {
-        return [
-            (0, ast_utils_1.insertImport)(this.options.source, this.options.source.fileName, this.decoratorName(), 'class-validator'),
-        ];
-    }
-    updateDecorator() {
-        if (!this.fieldNode)
-            throw new Error(`Field node is required for updating the ${this.decoratorName()} decorator`);
-        let newModifiers = [];
-        let existingModifiers = this.fieldNode.modifiers;
-        // Check if the field has an Length decorator.
-        //@ts-ignore
-        const existingDecorator = this.findDecorator(this.decoratorName(), existingModifiers);
-        //Remove the column decorator if the column decorator exists
-        //TODO probably this too can be done in a lesser intrusive way i.e update everything instead of removing and adding
-        newModifiers = [...this.filterNonDecorators(existingModifiers), ...this.filterOtherDecorators(this.decoratorName(), existingModifiers)];
-        //Add the column decorator if column decorator is required  
-        const changes = [];
-        if (this.isApplyDecorator()) {
-            newModifiers = [...newModifiers, this.createDecorator(existingDecorator)];
-            changes.push(...this.decoratorImports());
-        }
-        const updatedProperty = typescript_1.default.factory.updatePropertyDeclaration(this.fieldNode, newModifiers, //Replace with new modifiers
-        this.fieldNode.name, this.fieldNode.questionToken, this.fieldNode.type, this.fieldNode.initializer);
-        return [updatedProperty, changes];
-    }
-    createDecorator(existingDecorator) {
-        // Capture the existing column decorator options
-        const validationOptions = [];
-        if (existingDecorator !== undefined) {
-            //Pre-set the column options from the existing column decorator
-            const existingCallExpression = existingDecorator.expression;
-            // Check if  call expression has at least 1 arguments
-            if (existingCallExpression.arguments.length > 0) {
-                if (!typescript_1.default.isObjectLiteralExpression(existingCallExpression.arguments[0])) {
-                    throw new Error('Boolean decorator 1st argument must be an object literal containing the validation options');
-                }
-                const existingObjectLiteralExpression = existingCallExpression.arguments[0];
-                validationOptions.push(...existingObjectLiteralExpression.properties);
-            }
-        }
-        // Re-create the column decorator with the merged column decorator options
-        const decoratorIdentifier = typescript_1.default.factory.createIdentifier(this.decoratorName());
-        const argumentsArray = [];
-        if (validationOptions.length > 0) {
-            const validationOptionsObjectLiteral = typescript_1.default.factory.createObjectLiteralExpression(validationOptions);
-            argumentsArray.push(validationOptionsObjectLiteral);
-        }
-        const call = typescript_1.default.factory.createCallExpression(decoratorIdentifier, undefined, argumentsArray);
-        return typescript_1.default.factory.createDecorator(call);
-    }
-    findDecorator(name, existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator)).map(m => m).filter(m => this.containsIdentifierName(m, name)).pop() : undefined;
-    }
-    filterOtherDecorators(name, existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator)).map(m => m).filter(m => !this.containsIdentifierName(m, name)) : [];
-    }
-    filterNonDecorators(existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind !== typescript_1.default.SyntaxKind.Decorator)).map(m => m) : [];
-    }
-    containsIdentifierName(m, identifierName) {
-        const callExpression = m.expression;
-        const identifier = callExpression.expression;
-        return identifier.text === identifierName;
-    }
-}
-exports.BooleanDecoratorManager = BooleanDecoratorManager;
-//# sourceMappingURL=BooleanDecoratorManager.js.map

package/src/code-builder/lib/field/decorator-managers/dto/DateDecoratorManager.js

@@ -1,106 +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.DateDecoratorManager = void 0;
-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");
-class DateDecoratorManager {
-    constructor(options, fieldNode) {
-        this.options = options;
-        this.fieldNode = fieldNode;
-    }
-    isApplyDecorator() {
-        return this.options.isDate;
-    }
-    buildDecorator() {
-        const fieldSourceLines = [];
-        const changes = [];
-        // fieldSourceLines.push(`@Type(() => Date)`);
-        fieldSourceLines.push(`@${this.decoratorName()}()`);
-        changes.push(...this.decoratorImports());
-        return {
-            filePath: this.options.source.fileName,
-            field: this.options.field,
-            changes: changes,
-            fieldSourceLines: fieldSourceLines,
-        };
-    }
-    setFieldNode(fieldNode) {
-        this.fieldNode = fieldNode;
-    }
-    decoratorName() {
-        return 'IsDate';
-    }
-    decoratorImports() {
-        return [
-            (0, ast_utils_1.insertImport)(this.options.source, this.options.source.fileName, this.decoratorName(), 'class-validator'),
-        ];
-    }
-    updateDecorator() {
-        if (!this.fieldNode)
-            throw new Error(`Field node is required for updating the ${this.decoratorName()} decorator`);
-        let newModifiers = [];
-        let existingModifiers = this.fieldNode.modifiers;
-        // Check if the field has an Length decorator.
-        //@ts-ignore
-        const existingDecorator = this.findDecorator(this.decoratorName(), existingModifiers);
-        //Remove the column decorator if the column decorator exists
-        //TODO probably this too can be done in a lesser intrusive way i.e update everything instead of removing and adding
-        newModifiers = [...this.filterNonDecorators(existingModifiers), ...this.filterOtherDecorators(this.decoratorName(), existingModifiers)];
-        //Add the column decorator if column decorator is required  
-        const changes = [];
-        if (this.isApplyDecorator()) {
-            newModifiers = [...newModifiers, this.createDecorator(existingDecorator)];
-            changes.push(...this.decoratorImports());
-        }
-        const updatedProperty = typescript_1.default.factory.updatePropertyDeclaration(this.fieldNode, newModifiers, //Replace with new modifiers
-        this.fieldNode.name, this.fieldNode.questionToken, this.fieldNode.type, this.fieldNode.initializer);
-        return [updatedProperty, changes];
-    }
-    createDecorator(existingDecorator) {
-        // Capture the existing column decorator options
-        const validationOptions = [];
-        if (existingDecorator !== undefined) {
-            //Pre-set the column options from the existing column decorator
-            const existingCallExpression = existingDecorator.expression;
-            // Check if  call expression has at least 1 arguments
-            if (existingCallExpression.arguments.length > 0) {
-                if (!typescript_1.default.isObjectLiteralExpression(existingCallExpression.arguments[0])) {
-                    throw new Error('Date decorator 1st argument must be an object literal containing the validation options');
-                }
-                const existingObjectLiteralExpression = existingCallExpression.arguments[0];
-                validationOptions.push(...existingObjectLiteralExpression.properties);
-            }
-        }
-        // Re-create the column decorator with the merged column decorator options
-        const decoratorIdentifier = typescript_1.default.factory.createIdentifier("IsDate");
-        const argumentsArray = [];
-        if (validationOptions.length > 0) {
-            const validationOptionsObjectLiteral = typescript_1.default.factory.createObjectLiteralExpression(validationOptions);
-            argumentsArray.push(validationOptionsObjectLiteral);
-        }
-        const call = typescript_1.default.factory.createCallExpression(decoratorIdentifier, undefined, argumentsArray);
-        return typescript_1.default.factory.createDecorator(call);
-    }
-    findDecorator(name, existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator)).map(m => m).filter(m => this.containsIdentifierName(m, name)).pop() : undefined;
-    }
-    filterOtherDecorators(name, existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind === typescript_1.default.SyntaxKind.Decorator)).map(m => m).filter(m => !this.containsIdentifierName(m, name)) : [];
-    }
-    //   private filterNonTransformerDecorators(existingDecorators: ts.Decorator[]): ts.Decorator[] {
-    //     return existingDecorators ? existingDecorators.filter(m => !this.containsIdentifierName(m, 'Type')) : [];
-    //   }
-    filterNonDecorators(existingModifiers) {
-        return existingModifiers ? existingModifiers.filter((m) => (m.kind !== typescript_1.default.SyntaxKind.Decorator)).map(m => m) : [];
-    }
-    containsIdentifierName(m, identifierName) {
-        const callExpression = m.expression;
-        const identifier = callExpression.expression;
-        return identifier.text === identifierName;
-    }
-}
-exports.DateDecoratorManager = DateDecoratorManager;
-//# sourceMappingURL=DateDecoratorManager.js.map