@solidstarters/solid-code-builder 1.0.20 → 1.0.21

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

@@ -1,373 +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.BaseFieldManagerForEntity = 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 ColumnDecoratorManager_1 = require("../../decorator-managers/entity/ColumnDecoratorManager");
-const IndexDecoratorManager_1 = require("../../decorator-managers/entity/IndexDecoratorManager");
-const ManyToOneDecoratorManager_1 = require("../../decorator-managers/entity/ManyToOneDecoratorManager");
-const ManyToManyDecoratorManager_1 = require("../../decorator-managers/entity/ManyToManyDecoratorManager");
-const JoinTableDecoratorManager_1 = require("../../decorator-managers/entity/JoinTableDecoratorManager");
-const FieldManager_2 = require("../../FieldManager");
-const UniqueIndexDecoratorManager_1 = require("../../decorator-managers/entity/UniqueIndexDecoratorManager");
-class BaseFieldManagerForEntity {
-    constructor(tree, moduleName, modelName, field) {
-        var _a;
-        this.moduleName = moduleName;
-        this.modelName = modelName;
-        this.field = field;
-        // TODO: Note that the source file instance is created during construction
-        // So every operation should use a new instance of the field manager, so updated tree/source is used before each operation
-        this.source = (0, FieldManager_1.createSourceFile)(tree, `src/${(0, strings_1.dasherize)(moduleName)}/entities/${(0, strings_1.dasherize)(modelName)}.entity.ts`);
-        // this.relationInverseSource = createSourceFile(tree, `src/${dasherize(this.field.relationModelSingularName)}/dtos/create-${dasherize(this.field.relationModelSingularName)}.dto.ts`)
-        const fieldPropertyDeclarationNode = (_a = this.getFieldIdentifierNode(this.fieldName(), this.source)) === null || _a === void 0 ? void 0 : _a.parent;
-        this.indexDecoratorManager = new IndexDecoratorManager_1.IndexDecoratorManager({ index: this.field.index, source: this.source, field: this.field }, fieldPropertyDeclarationNode);
-        this.columnDecoratorManager = new ColumnDecoratorManager_1.ColumnDecoratorManager({
-            isColumn: this.isColumn(),
-            columnName: this.field.columnName,
-            type: this.field.ormType,
-            required: this.field.required,
-            otherOptions: this.additionalColumnDecoratorOptions(),
-            otherOptionExpressions: this.additionalColumnDecoratorOptionExpressions(),
-            source: this.source,
-            field: this.field,
-        }, fieldPropertyDeclarationNode);
-        this.manyToOneDecoratorManager = new ManyToOneDecoratorManager_1.ManyToOneDecoratorManager({
-            isManyToOne: this.isManyToOne(),
-            relationModelSingularName: this.field.relationModelSingularName,
-            relationCascade: this.field.relationCascade,
-            required: this.field.required,
-            source: this.source,
-            field: this.field,
-            fieldName: this.fieldName(),
-            modelName: this.modelName,
-        }, fieldPropertyDeclarationNode);
-        this.manyToManyDecoratorManager = new ManyToManyDecoratorManager_1.ManyToManyDecoratorManager({
-            isManyToMany: this.isManyToMany(),
-            relationModelName: this.field.relationModelSingularName,
-            relationInverseFieldName: this.field.relationModelFieldName,
-            relationCascade: this.field.relationCascade,
-            owner: true,
-            source: this.source,
-            field: this.field,
-            fieldName: this.fieldName(),
-            modelName: this.modelName,
-        });
-        this.joinTableDecoratorManager = new JoinTableDecoratorManager_1.JoinTableDecoratorManager({
-            isManyToManyRelationOwner: this.field.relationType === FieldManager_2.RelationType.ManyToMany,
-            source: this.source,
-            field: this.field,
-            fieldName: this.fieldName(),
-            modelName: this.modelName,
-        });
-        this.uniqueIndexDecoratorManager = new UniqueIndexDecoratorManager_1.UniqueIndexDecoratorManager({ unique: this.field.unique, fieldName: this.fieldName(), source: this.source, field: this.field }, this.getClassNode(this.modelName, this.source));
-    }
-    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 entity field declaration
-        let entityPropertyLine = this.buildPropertyLine(fieldName, fieldType, field.defaultValue);
-        fieldSourceLines.push(entityPropertyLine);
-        //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 classNode = this.getClassNode(modelName, source);
-        const fieldDefinition = `\n${fieldSourceLines.reverse().join('\n')}\n`;
-        changes.push(new change_1.InsertChange(source.fileName, classNode.end - 1, fieldDefinition));
-        // Apply the unique index decorator changes at the class node level
-        const uniqueIndexDecoratorChanges = this.uniqueIndexDecoratorManager.buildDecorator();
-        changes.push(...uniqueIndexDecoratorChanges.changes);
-        const classDecoratorLines = `${uniqueIndexDecoratorChanges.fieldSourceLines.reverse().join('\n')}\n`;
-        const classExportKeywordNode = (0, FieldManager_1.getClassExportKeywordNode)((0, strings_1.classify)(modelName), source);
-        if (!classExportKeywordNode) {
-            throw new Error(`Export keyword not found for class ${modelName} in file ${source.fileName}`);
-        }
-        const classExportKeywordStartPosition = classExportKeywordNode.getStart(source);
-        changes.push(new change_1.InsertChange(source.fileName, classExportKeywordStartPosition, classDecoratorLines));
-        return {
-            filePath: source.fileName,
-            field: field,
-            changes: changes,
-        };
-    }
-    uniqueIndexDecoratorChanges() {
-        const changes = [];
-        const [updatedClassNode, indexDecoratorChanges] = this.uniqueIndexDecoratorManager.updateDecorator();
-        changes.push(...indexDecoratorChanges);
-        return [updatedClassNode, changes];
-        // changes.push(...this.calculateReplaceChanges(this.printNode(updatedClassNode, source), classNode, source));
-    }
-    getClassNode(modelName, source) {
-        const className = (0, strings_1.classify)(modelName);
-        const classNode = (0, FieldManager_1.getClassNode)(className, source);
-        if (!classNode) {
-            throw new Error(`Class ${className} not found in file ${source.fileName}`);
-        }
-        return classNode;
-    }
-    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, _b;
-        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);
-        updatedPropertyDeclarationNode =
-            this.updateFieldInitializer(fieldPropertyDeclarationNode, (_b = this.defaultValueInitializer(field.defaultValue)) === null || _b === void 0 ? void 0 : _b.expression);
-        // Apply the decorator transformations  to the field property declaration node
-        const [updatedPropertyDeclarationNodeTransformed, decoratorChanges] = this.applyUpdateDecoratorTransformations(updatedPropertyDeclarationNode, ...decoratorManagers);
-        updatedPropertyDeclarationNode = updatedPropertyDeclarationNodeTransformed;
-        changes.push(...decoratorChanges);
-        // Update the property declaration node in the class hierarchy with the updated property declaration node
-        // Then calculate the replace changes
-        // changes.push(...this.calculateReplaceChanges(this.printNode(updatedPropertyDeclarationNode, source), fieldPropertyDeclarationNode, source));
-        this.uniqueIndexDecoratorManager.setFieldNode(updatedPropertyDeclarationNode);
-        // Apply the unique index decorator changes at the class node level
-        const [updatedClassNode, uniqueIndexDecoratorChanges] = this.uniqueIndexDecoratorChanges();
-        changes.push(...uniqueIndexDecoratorChanges);
-        changes.push(...this.calculateReplaceChanges(this.printNode(updatedClassNode, source), this.getClassNode(this.modelName, source), source)); //FIXME: this.modelName to passed in for avoiding statefullness
-        // this.uniqueIndexDecoratorChanges(changes, source, this.getClassNode(this.modelName, source));
-        return {
-            filePath: source.fileName,
-            field: field,
-            changes: changes,
-        };
-    }
-    updateField() {
-        const fieldChanges = [];
-        console.log(`\nentity 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;
-    }
-    //TODO how to handle scenarios, wherein fieldname() implementation has changed later, after add field code was autogenerated
-    removeField() {
-        const fieldChanges = [];
-        console.log(`Entity removeField ${this.fieldName()} called ...`);
-        fieldChanges.push(this.removeFieldFor(this.fieldName(), this.source));
-        if (this.isAdditionalFieldRequired()) {
-            fieldChanges.push(this.removeAdditionalField());
-        }
-        return fieldChanges;
-    }
-    removeFieldFor(fieldName, fieldSource) {
-        const fieldIdentifierNode = this.getFieldIdentifierNode(fieldName, fieldSource);
-        if (fieldIdentifierNode == null) {
-            return {
-                filePath: fieldSource.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()),
-            ],
-        };
-    }
-    calculateReplaceChanges(updateNodeText, sourceNode, source) {
-        const changes = [];
-        if (updateNodeText.trim() !==
-            sourceNode.getFullText().trim()) {
-            console.log(`Updated Code:\n${updateNodeText.trim()}\nwith length ${updateNodeText.trim().length}\n`);
-            console.log(`Old Code:\n${sourceNode.getFullText().trim()}\nwith length ${sourceNode.getFullText().trim().length}\n`);
-            const replaceChange = new FieldManager_1.ReplaceChangeSSS(source.fileName, sourceNode.pos, sourceNode.getFullText(), `\n\n${updateNodeText}`);
-            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;
-    }
-    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;
-    }
-    fieldName() {
-        return this.field.name;
-    }
-    additionalColumnDecoratorOptions() {
-        return new Map();
-    }
-    additionalColumnDecoratorOptionExpressions() {
-        return new Map();
-    }
-    updateFieldType(fieldPropertyDeclarationNode, newTypeNode) {
-        if (!newTypeNode)
-            return fieldPropertyDeclarationNode;
-        const updatedPropertyDeclaration = typescript_1.default.factory.updatePropertyDeclaration(fieldPropertyDeclarationNode, fieldPropertyDeclarationNode.modifiers, fieldPropertyDeclarationNode.name, fieldPropertyDeclarationNode.questionToken, newTypeNode, // Replace with new type node
-        fieldPropertyDeclarationNode.initializer);
-        return updatedPropertyDeclaration;
-    }
-    updateFieldInitializer(fieldPropertyDeclarationNode, initializer) {
-        if (!initializer)
-            return fieldPropertyDeclarationNode;
-        const updatedPropertyDeclaration = typescript_1.default.factory.updatePropertyDeclaration(fieldPropertyDeclarationNode, fieldPropertyDeclarationNode.modifiers, fieldPropertyDeclarationNode.name, fieldPropertyDeclarationNode.questionToken, fieldPropertyDeclarationNode.type, initializer // Replace with new initializer
-        );
-        return updatedPropertyDeclaration;
-    }
-    inverseRelationFieldName() {
-        return `${this.field.relationModelSingularName}s`;
-    }
-    isManyToOne() {
-        return (this.field.type === 'relation' && this.field.relationType === FieldManager_2.RelationType.ManyToOne);
-    }
-    isAdditionalFieldRequired() {
-        return false;
-    }
-    isManyToMany() {
-        return (this.field.type === 'relation' && this.field.relationType === FieldManager_2.RelationType.ManyToMany);
-    }
-    isColumn() {
-        return this.field.type !== 'relation';
-    }
-    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;
-                partialFieldChanges.push(transformer.buildDecorator());
-            };
-        }
-    }
-    decoratorManagers() {
-        return [this.indexDecoratorManager, this.columnDecoratorManager, this.manyToOneDecoratorManager, this.manyToManyDecoratorManager, this.joinTableDecoratorManager];
-    }
-    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: [],
-        };
-    }
-    additionalFieldName() {
-        throw new Error(`additionalFieldName method not implemented for field ${this.fieldName()} of type ${this.field.type}`);
-    }
-    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.BaseFieldManagerForEntity = BaseFieldManagerForEntity;
-//# sourceMappingURL=BaseFieldManagerForEntity.js.map

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

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeleteType = void 0;
-var DeleteType;
-(function (DeleteType) {
-    DeleteType["CASCADE"] = "CASCADE";
-    DeleteType["RESTRICT"] = "RESTRICT";
-    DeleteType["SET_NULL"] = "SET_NULL";
-    DeleteType["SET_DEFAULT"] = "SET_DEFAULT";
-})(DeleteType || (exports.DeleteType = DeleteType = {}));
-//# sourceMappingURL=DeleteType.js.map

package/src/code-builder/lib/field/field-managers/bigint/BigIntFieldHandler.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BigIntFieldHandler = void 0;
-const FieldManager_1 = require("../../FieldManager");
-const BigIntFieldManagerForDto_1 = require("./BigIntFieldManagerForDto");
-const BigIntFieldManagerForEntity_1 = require("./BigIntFieldManagerForEntity");
-class BigIntFieldHandler {
-    constructor(tree, moduleName, modelName, field) {
-        this.entityFieldManager = new BigIntFieldManagerForEntity_1.BigIntFieldManagerForEntity(tree, moduleName, modelName, field);
-        this.createDtoFieldManager = new BigIntFieldManagerForDto_1.BigIntFieldManagerForDto(tree, moduleName, modelName, field, new FieldManager_1.ManagerForDtoOptions(FieldManager_1.DtoSourceType.Create));
-        this.updateDtoFieldManager = new BigIntFieldManagerForDto_1.BigIntFieldManagerForDto(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.BigIntFieldHandler = BigIntFieldHandler;
-//# sourceMappingURL=BigIntFieldHandler.js.map

package/src/code-builder/lib/field/field-managers/bigint/BigIntFieldManagerForDto.js

@@ -1,81 +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.BigIntFieldManagerForDto = void 0;
-const typescript_1 = __importDefault(require("@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript"));
-const BaseFieldManagerForDto_1 = require("../base/BaseFieldManagerForDto");
-class BigIntFieldManagerForDto extends BaseFieldManagerForDto_1.BaseFieldManagerForDto {
-    isJson() {
-        return false;
-    }
-    isBoolean() {
-        return false;
-    }
-    constructor(tree, moduleName, modelName, field, options) {
-        super(tree, moduleName, modelName, field, options);
-    }
-    isString() {
-        return false;
-    }
-    isNumber() {
-        return false;
-    }
-    isInt() {
-        return false;
-    }
-    isDecimal() {
-        return false;
-    }
-    isBigInt() {
-        return true;
-    }
-    isApplyRegex() {
-        return false;
-    }
-    isApplyRequired() {
-        return true;
-    }
-    isApplyMin() {
-        return true;
-    }
-    isApplyMax() {
-        return true;
-    }
-    isDate() {
-        return false;
-    }
-    isTransform() {
-        return false;
-    }
-    fieldType() {
-        return {
-            text: 'bigint',
-            node: (_field) => typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.BigIntKeyword),
-        };
-    }
-    parseDefaultValue(defaultValue) {
-        if (!defaultValue)
-            return null;
-        try {
-            return BigInt(defaultValue);
-        }
-        catch (e) {
-            // console.log(`Could not set default value ${defaultValue}  for field ${this.field.name} in model ${this.modelName}`);
-            return null;
-        }
-    }
-    defaultValueInitializer(defaultValueConfig) {
-        const defaultValue = this.parseDefaultValue(defaultValueConfig);
-        if (!defaultValue)
-            return null;
-        return {
-            value: defaultValue,
-            text: `${defaultValue.toString()}n`,
-            expression: typescript_1.default.factory.createBigIntLiteral(defaultValue.toString())
-        };
-    }
-}
-exports.BigIntFieldManagerForDto = BigIntFieldManagerForDto;
-//# sourceMappingURL=BigIntFieldManagerForDto.js.map

package/src/code-builder/lib/field/field-managers/bigint/BigIntFieldManagerForEntity.js

@@ -1,55 +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.BigIntFieldManagerForEntity = void 0;
-const typescript_1 = __importDefault(require("@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript"));
-const BaseFieldManagerForEntity_1 = require("../base/BaseFieldManagerForEntity");
-class BigIntFieldManagerForEntity extends BaseFieldManagerForEntity_1.BaseFieldManagerForEntity {
-    constructor(tree, moduleName, modelName, field) {
-        super(tree, moduleName, modelName, field);
-    }
-    fieldType() {
-        return {
-            text: 'bigint',
-            node: (_field) => typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.BigIntKeyword),
-        };
-    }
-    additionalColumnDecoratorOptions() {
-        var _a, _b;
-        // Parse the default value from the field & set it to the column options
-        const options = new Map();
-        options.set('default', (_b = (_a = this.defaultValueInitializer(this.field.defaultValue)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : null);
-        return options;
-    }
-    additionalColumnDecoratorOptionExpressions() {
-        var _a, _b;
-        const options = new Map();
-        options.set('default', (_b = (_a = this.defaultValueInitializer(this.field.defaultValue)) === null || _a === void 0 ? void 0 : _a.expression) !== null && _b !== void 0 ? _b : null);
-        return options;
-    }
-    parseDefaultValue(defaultValue) {
-        if (!defaultValue)
-            return null;
-        try {
-            return BigInt(defaultValue);
-        }
-        catch (e) {
-            // console.log(`Could not set default value ${defaultValue}  for field ${this.field.name} in model ${this.modelName}`);
-            return null;
-        }
-    }
-    defaultValueInitializer(defaultValueConfig) {
-        const defaultValue = this.parseDefaultValue(defaultValueConfig);
-        if (!defaultValue)
-            return null;
-        return {
-            value: defaultValue,
-            text: `${defaultValue.toString()}n`,
-            expression: typescript_1.default.factory.createBigIntLiteral(defaultValue.toString())
-        };
-    }
-}
-exports.BigIntFieldManagerForEntity = BigIntFieldManagerForEntity;
-//# sourceMappingURL=BigIntFieldManagerForEntity.js.map

package/src/code-builder/lib/field/field-managers/boolean/BooleanFieldHandler.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BooleanFieldHandler = void 0;
-const FieldManager_1 = require("../../FieldManager");
-const BooleanFieldManagerForDto_1 = require("./BooleanFieldManagerForDto");
-const BooleanFieldManagerForEntity_1 = require("./BooleanFieldManagerForEntity");
-class BooleanFieldHandler {
-    constructor(tree, moduleName, modelName, field) {
-        this.entityFieldManager = new BooleanFieldManagerForEntity_1.BooleanFieldManagerForEntity(tree, moduleName, modelName, field);
-        this.createDtoFieldManager = new BooleanFieldManagerForDto_1.BooleanFieldManagerForDto(tree, moduleName, modelName, field, new FieldManager_1.ManagerForDtoOptions(FieldManager_1.DtoSourceType.Create));
-        this.updateDtoFieldManager = new BooleanFieldManagerForDto_1.BooleanFieldManagerForDto(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.BooleanFieldHandler = BooleanFieldHandler;
-//# sourceMappingURL=BooleanFieldHandler.js.map

package/src/code-builder/lib/field/field-managers/boolean/BooleanFieldManagerForDto.js

@@ -1,75 +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.BooleanFieldManagerForDto = void 0;
-const typescript_1 = __importDefault(require("@schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript"));
-const BaseFieldManagerForDto_1 = require("../base/BaseFieldManagerForDto");
-class BooleanFieldManagerForDto extends BaseFieldManagerForDto_1.BaseFieldManagerForDto {
-    isJson() {
-        return false;
-    }
-    isBoolean() {
-        return true;
-    }
-    constructor(tree, moduleName, modelName, field, options) {
-        super(tree, moduleName, modelName, field, options);
-    }
-    isString() {
-        return false;
-    }
-    isNumber() {
-        return false;
-    }
-    isInt() {
-        return false;
-    }
-    isDecimal() {
-        return false;
-    }
-    isApplyRegex() {
-        return false;
-    }
-    isApplyRequired() {
-        return true;
-    }
-    isApplyMin() {
-        return false;
-    }
-    isApplyMax() {
-        return false;
-    }
-    isDate() {
-        return false;
-    }
-    isTransform() {
-        return false;
-    }
-    fieldType() {
-        return {
-            text: 'boolean',
-            node: (_field) => typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.BooleanKeyword),
-        };
-    }
-    parseDefaultValue(defaultValue) {
-        try {
-            return Boolean(defaultValue);
-        }
-        catch (e) {
-            // console.log(`Could not set default value ${defaultValue}  for field ${this.field.name} in model ${this.modelName}`);
-        }
-        return null;
-    }
-    defaultValueInitializer(defaultValueConfig) {
-        var _a;
-        const defaultValue = (_a = this.parseDefaultValue(defaultValueConfig)) !== null && _a !== void 0 ? _a : false;
-        return {
-            value: defaultValue,
-            text: defaultValue.toString(),
-            expression: defaultValue ? typescript_1.default.factory.createTrue() : typescript_1.default.factory.createFalse()
-        };
-    }
-}
-exports.BooleanFieldManagerForDto = BooleanFieldManagerForDto;
-//# sourceMappingURL=BooleanFieldManagerForDto.js.map