@solidstarters/solid-code-builder 1.0.19 → 1.0.21

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

@@ -1,104 +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.OptionalDecoratorManager = 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 OptionalDecoratorManager {
-    constructor(options, fieldNode) {
-        this.options = options;
-        this.fieldNode = fieldNode;
-    }
-    isApplyDecorator() {
-        return this.options.isApplyOptional && this.options.optional;
-    }
-    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 'IsOptional';
-    }
-    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
-        let existingValidationOptions = this.existingDecoratorOptions(existingDecorator);
-        // Re-create the decorator with the existing decorator options
-        const decoratorIdentifier = typescript_1.default.factory.createIdentifier(this.decoratorName());
-        const argumentsArray = [];
-        if (existingValidationOptions.length > 0) {
-            const validationOptionsObjectLiteral = typescript_1.default.factory.createObjectLiteralExpression(existingValidationOptions);
-            argumentsArray.push(validationOptionsObjectLiteral);
-        }
-        const call = typescript_1.default.factory.createCallExpression(decoratorIdentifier, undefined, argumentsArray);
-        return typescript_1.default.factory.createDecorator(call);
-    }
-    existingDecoratorOptions(existingDecorator) {
-        let 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('IsOptional 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.OptionalDecoratorManager = OptionalDecoratorManager;
-//# sourceMappingURL=OptionalDecoratorManager.js.map

package/src/code-builder/lib/field/decorator-managers/dto/RegexDecoratorManager.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.RegexDecoratorManager = 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 RegexDecoratorManager {
-    constructor(options, fieldNode) {
-        this.options = options;
-        this.fieldNode = fieldNode;
-    }
-    isApplyDecorator() {
-        return this.options.isApplyRegex && this.options.regexPattern !== null && this.options.regexPattern !== undefined && this.options.regexPattern.trim().length > 0;
-    }
-    buildDecorator() {
-        const fieldSourceLines = [];
-        const changes = [];
-        fieldSourceLines.push(`@Matches(/${this.options.regexPattern}/)`);
-        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 'Matches';
-    }
-    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
-        let 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 > 1) {
-                if (!typescript_1.default.isObjectLiteralExpression(existingCallExpression.arguments[1])) {
-                    throw new Error('Regex decorator 2nd argument must be an object literal containing the validation options');
-                }
-                const existingObjectLiteralExpression = existingCallExpression.arguments[1];
-                validationOptions.push(...existingObjectLiteralExpression.properties);
-            }
-        }
-        // Re-create the column decorator with the merged column decorator options
-        const decoratorIdentifier = typescript_1.default.factory.createIdentifier("Matches");
-        const argumentsArray = [];
-        const regexPattern = typescript_1.default.factory.createRegularExpressionLiteral(`/${this.options.regexPattern}/`);
-        argumentsArray.push(regexPattern);
-        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.RegexDecoratorManager = RegexDecoratorManager;
-//# sourceMappingURL=RegexDecoratorManager.js.map

package/src/code-builder/lib/field/decorator-managers/dto/RequiredDecoratorManager.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.RequiredDecoratorManager = 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 RequiredDecoratorManager {
-    constructor(options, fieldNode) {
-        this.options = options;
-        this.fieldNode = fieldNode;
-    }
-    isApplyDecorator() {
-        return this.options.isApplyRequired && this.options.required;
-    }
-    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 'IsNotEmpty';
-    }
-    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
-        let 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('IsNotEmpty 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.RequiredDecoratorManager = RequiredDecoratorManager;
-//# sourceMappingURL=RequiredDecoratorManager.js.map

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

@@ -1,99 +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.StringDecoratorManager = 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 StringDecoratorManager {
-    constructor(options, fieldNode) {
-        this.options = options;
-        this.fieldNode = fieldNode;
-    }
-    isApplyDecorator() {
-        return this.options.isString;
-    }
-    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 'IsString';
-    }
-    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.
-        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
-        let 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 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.StringDecoratorManager = StringDecoratorManager;
-//# sourceMappingURL=StringDecoratorManager.js.map

package/src/code-builder/lib/field/decorator-managers/dto/TransformDecoratorManager.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.TransformDecoratorManager = 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 TransformDecoratorManager {
-    constructor(options, fieldNode) {
-        this.options = options;
-        this.fieldNode = fieldNode;
-    }
-    isApplyDecorator() {
-        return this.options.isTransform;
-    }
-    buildDecorator() {
-        const fieldSourceLines = [];
-        const changes = [];
-        fieldSourceLines.push(`@${this.decoratorName()}(() => ${this.options.type})`);
-        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 'Type';
-    }
-    decoratorImports() {
-        return [(0, ast_utils_1.insertImport)(this.options.source, this.options.source.fileName, this.decoratorName(), 'class-transformer')];
-    }
-    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 Transform decorator.
-        //@ts-ignore
-        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 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 2 arguments
-            if (existingCallExpression.arguments.length > 1) {
-                if (!typescript_1.default.isObjectLiteralExpression(existingCallExpression.arguments[1])) {
-                    throw new Error('Transform decorator 1st argument must be an object literal containing the validation options');
-                }
-                const existingObjectLiteralExpression = existingCallExpression.arguments[1];
-                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 = [];
-        const transformFunction = typescript_1.default.factory.createArrowFunction(undefined, undefined, [], undefined, typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.EqualsGreaterThanToken), typescript_1.default.factory.createIdentifier(this.options.type));
-        argumentsArray.push(transformFunction);
-        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.TransformDecoratorManager = TransformDecoratorManager;
-//# sourceMappingURL=TransformDecoratorManager.js.map

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

@@ -1,140 +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.ValidateNestedDecoratorManager = 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 ValidateNestedDecoratorManager {
-    constructor(options, fieldNode) {
-        this.options = options;
-        this.fieldNode = fieldNode;
-    }
-    isApplyDecorator() {
-        return this.options.isValidateNested;
-    }
-    buildDecorator() {
-        const fieldSourceLines = [];
-        const changes = [];
-        fieldSourceLines.push(`@${this.decoratorName()}(${this.buildValidationOptionsCode()})`);
-        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 'ValidateNested';
-    }
-    decoratorImports() {
-        return [(0, ast_utils_1.insertImport)(this.options.source, this.options.source.fileName, this.decoratorName(), 'class-validator')];
-    }
-    buildValidationOptionsCode() {
-        return `{ each : true }`;
-    }
-    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);
-        //Merge the options with the existing options
-        const mergedValidationOptions = this.mergeExistingAndNewValidationOptions(validationOptions);
-        // Re-create the isArray decorator with the existing isArray decorator options
-        const decoratorIdentifier = typescript_1.default.factory.createIdentifier(this.decoratorName());
-        const argumentsArray = this.createDecoratorArguments(mergedValidationOptions);
-        const call = typescript_1.default.factory.createCallExpression(decoratorIdentifier, undefined, argumentsArray);
-        return typescript_1.default.factory.createDecorator(call);
-    }
-    mergeExistingAndNewValidationOptions(validationOptions) {
-        const decoratorOptions = this.createValidationDecoratorOptions();
-        const mergedValidationOptions = Array.from(decoratorOptions.values()).filter(p => p !== null);
-        // console.log('mergedValidationOptions', mergedValidationOptions.map(p => JSON.stringify(p.name)).join(', '));
-        // Add the other unhandled column decorator options
-        const handledDecoratorOptions = Array.from(decoratorOptions.keys());
-        //@ts-ignore
-        const otherPropertyAssignments = validationOptions.filter(ps => { var _a; return !handledDecoratorOptions.includes((_a = ps.name) === null || _a === void 0 ? void 0 : _a.escapedText); });
-        mergedValidationOptions.push(...otherPropertyAssignments);
-        return mergedValidationOptions;
-    }
-    createValidationDecoratorOptions() {
-        const options = new Map();
-        options.set('each', typescript_1.default.factory.createTrue());
-        return this.optionsToPropertyAssignmentsOrNull(options);
-    }
-    optionsToPropertyAssignmentsOrNull(options) {
-        const decoratorOptions = new Map();
-        options.forEach((value, key) => {
-            if (value !== null) {
-                decoratorOptions.set(key, typescript_1.default.factory.createPropertyAssignment(typescript_1.default.factory.createIdentifier(key), value));
-            }
-            else {
-                decoratorOptions.set(key, null);
-            }
-        });
-        return decoratorOptions;
-    }
-    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('ValidateNested 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.ValidateNestedDecoratorManager = ValidateNestedDecoratorManager;
-//# sourceMappingURL=ValidateNestedDecoratorManager.js.map