UNPKG

generator-pyhipster

Version:

Python (Flask) + Angular/React/Vue in one handy generator

1,178 lines (1,142 loc) 38.9 kB
/** * Copyright 2013-2022 the original author or authors from the JHipster project. * * This file is part of the JHipster project, see https://www.jhipster.tech/ * for more information. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * https://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const chalk = require('chalk'); const fs = require('fs'); const _ = require('lodash'); const constants = require('../generator-constants'); const { isReservedPaginationWords, isReservedFieldName, isReservedTableName } = require('../../jdl/jhipster/reserved-keywords'); const { CASSANDRA, ORACLE, SQL } = require('../../jdl/jhipster/database-types'); const databaseTypes = require('../../jdl/jhipster/database-types'); const { GATEWAY } = require('../../jdl/jhipster/application-types'); const { FilteringTypes, MapperTypes, ServiceTypes, PaginationTypes } = require('../../jdl/jhipster/entity-options'); const { JPA_METAMODEL } = FilteringTypes; const NO_FILTERING = FilteringTypes.NO; const { INFINITE_SCROLL, PAGINATION } = PaginationTypes; const NO_PAGINATION = PaginationTypes.NO; const { SERVICE_IMPL, SERVICE_CLASS } = ServiceTypes; const NO_SERVICE = ServiceTypes.NO; const { MAPSTRUCT } = MapperTypes; const NO_MAPPER = MapperTypes.NO; const NO_DATABASE = databaseTypes.NO; const ANGULAR = constants.SUPPORTED_CLIENT_FRAMEWORKS.ANGULAR; const REACT = constants.SUPPORTED_CLIENT_FRAMEWORKS.REACT; const { CommonDBTypes, RelationalOnlyDBTypes, BlobTypes } = require('../../jdl/jhipster/field-types'); const { BIG_DECIMAL, BOOLEAN, DOUBLE, DURATION, ENUM, FLOAT, INTEGER, INSTANT, LOCAL_DATE, LONG, STRING, UUID, ZONED_DATE_TIME } = CommonDBTypes; const { BYTES, BYTE_BUFFER } = RelationalOnlyDBTypes; const { ANY, IMAGE, TEXT } = BlobTypes; const { PATTERN, MINBYTES, MAXBYTES, MINLENGTH, MAXLENGTH, MIN, MAX, REQUIRED, UNIQUE } = require('../../jdl/jhipster/validations'); module.exports = { askForMicroserviceJson, askForUpdate, askForFields, askForFieldsToRemove, askForRelationships, askForRelationsToRemove, askForTableName, askForDTO, askForService, askForFiltering, askForReadOnly, askForPagination, }; const getFieldNameUndercored = fields => ['id'].concat( fields.map(field => { return _.snakeCase(field.fieldName); }) ); function askForMicroserviceJson() { const context = this.context; if (this.jhipsterConfig.applicationType !== GATEWAY || context.configExisted) { return undefined; } const databaseType = this.jhipsterConfig.databaseType; const prompts = [ { when: () => databaseType !== NO_DATABASE, type: 'confirm', name: 'useMicroserviceJson', message: 'Do you want to generate this entity from an existing microservice?', default: true, }, { when: response => response.useMicroserviceJson === true || databaseType === NO_DATABASE, type: 'input', name: 'microservicePath', message: 'Enter the path to the microservice root directory:', store: true, default: this.entityConfig.microservicePath, validate: input => { if (fs.existsSync(this.destinationPath(input, context.filename))) { return true; } return `${context.filename} not found in ${input}/`; }, }, ]; return this.prompt(prompts).then(answers => { if (answers.microservicePath) { this.log(chalk.green(`\nFound the ${context.filename} configuration file, entity can be automatically generated!\n`)); context.microservicePath = this.entityConfig.microservicePath = answers.microservicePath; } }); } function askForUpdate() { const context = this.context; // ask only if running an existing entity without arg option --force or --regenerate const isForce = this.options.force || context.regenerate; context.updateEntity = 'regenerate'; // default if skipping questions by --force if (isForce || !context.useConfigurationFile) { return undefined; } const prompts = [ { type: 'list', name: 'updateEntity', message: 'Do you want to update the entity? This will replace the existing files for this entity, all your custom code will be overwritten', choices: [ { value: 'regenerate', name: 'Yes, re generate the entity', }, { value: 'add', name: 'Yes, add more fields and relationships', }, { value: 'remove', name: 'Yes, remove fields and relationships', }, { value: 'none', name: 'No, exit', }, ], default: 0, }, ]; return this.prompt(prompts).then(props => { context.updateEntity = props.updateEntity; if (context.updateEntity === 'none') { throw new Error(chalk.green('Aborting entity update, no changes were made.')); } }); } function askForFields() { const context = this.context; // don't prompt if data is imported from a file if (this.options.defaults || (context.useConfigurationFile && context.updateEntity !== 'add')) { return undefined; } if (context.updateEntity === 'add') { logFieldsAndRelationships.call(this); } return askForField.call(this); } function askForFieldsToRemove() { const context = this.context; // prompt only if data is imported from a file if (!context.useConfigurationFile || context.updateEntity !== 'remove' || this.entityConfig.fields.length === 0) { return undefined; } const prompts = [ { type: 'checkbox', name: 'fieldsToRemove', message: 'Please choose the fields you want to remove', choices: () => this.entityConfig.fields.map(field => { return { name: field.fieldName, value: field.fieldName }; }), }, { when: response => response.fieldsToRemove.length !== 0, type: 'confirm', name: 'confirmRemove', message: 'Are you sure to remove these fields?', default: true, }, ]; return this.prompt(prompts).then(props => { if (props.confirmRemove) { this.log(chalk.red(`\nRemoving fields: ${props.fieldsToRemove}\n`)); const fields = this.entityConfig.fields; for (let i = fields.length - 1; i >= 0; i -= 1) { const field = this.entityConfig.fields[i]; if (props.fieldsToRemove.filter(val => val === field.fieldName).length > 0) { fields.splice(i, 1); } } this.entityConfig.fields = fields; } }); } function askForRelationships() { const context = this.context; if (this.options.defaults) { return undefined; } // don't prompt if data is imported from a file if (context.useConfigurationFile && context.updateEntity !== 'add') { return undefined; } if (context.databaseType === CASSANDRA) { return undefined; } return askForRelationship.call(this); } function askForRelationsToRemove() { const context = this.context; // prompt only if data is imported from a file if (!context.useConfigurationFile || context.updateEntity !== 'remove' || this.entityConfig.relationships.length === 0) { return undefined; } if (context.databaseType === CASSANDRA) { return undefined; } const prompts = [ { type: 'checkbox', name: 'relsToRemove', message: 'Please choose the relationships you want to remove', choices: () => this.entityConfig.relationships.map(rel => { return { name: `${rel.relationshipName}:${rel.relationshipType}`, value: `${rel.relationshipName}:${rel.relationshipType}`, }; }), }, { when: response => response.relsToRemove.length !== 0, type: 'confirm', name: 'confirmRemove', message: 'Are you sure to remove these relationships?', default: true, }, ]; return this.prompt(prompts).then(props => { if (props.confirmRemove) { this.log(chalk.red(`\nRemoving relationships: ${props.relsToRemove}\n`)); const relationships = this.entityConfig.relationships; for (let i = relationships.length - 1; i >= 0; i -= 1) { const rel = relationships[i]; if (props.relsToRemove.filter(val => val === `${rel.relationshipName}:${rel.relationshipType}`).length > 0) { relationships.splice(i, 1); } } this.entityConfig.relationships = relationships; } }); } function askForTableName() { const context = this.context; // don't prompt if there are no relationships const entityTableName = context.entityTableName; const prodDatabaseType = context.prodDatabaseType; const skipCheckLengthOfIdentifier = context.skipCheckLengthOfIdentifier; if ( skipCheckLengthOfIdentifier || !this.entityConfig.relationships || this.entityConfig.relationships.length === 0 || !((prodDatabaseType === ORACLE && entityTableName.length > 14) || entityTableName.length > 30) ) { return undefined; } const prompts = [ { type: 'input', name: 'entityTableName', message: 'The table name for this entity is too long to form constraint names. Please use a shorter table name', validate: input => { if (!/^([a-zA-Z0-9_]*)$/.test(input)) { return 'The table name cannot contain special characters'; } if (input === '') { return 'The table name cannot be empty'; } if (prodDatabaseType === 'oracle' && input.length > 14 && !skipCheckLengthOfIdentifier) { return 'The table name is too long for Oracle, try a shorter name'; } if (input.length > 30 && !skipCheckLengthOfIdentifier) { return 'The table name is too long, try a shorter name'; } return true; }, default: entityTableName, }, ]; return this.prompt(prompts).then(props => { /* overwrite the table name for the entity using name obtained from the user */ if (props.entityTableName !== this.entityConfig.entityTableName) { context.entityTableName = this.entityConfig.entityTableName = _.snakeCase(props.entityTableName).toLowerCase(); } }); } function askForFiltering() { const context = this.context; // don't prompt if server is skipped, or the backend is not sql, or no service requested if (context.useConfigurationFile || context.skipServer || context.databaseType !== 'sql' || this.entityConfig.service === 'no') { return undefined; } const prompts = [ { type: 'list', name: 'filtering', message: 'Do you want to add filtering?', choices: [ { value: NO_FILTERING, name: 'Not needed', }, { name: 'Dynamic filtering for the entities with JPA Static metamodel', value: JPA_METAMODEL, }, ], default: 0, }, ]; return this.prompt(prompts).then(props => { this.entityConfig.jpaMetamodelFiltering = props.filtering === JPA_METAMODEL; }); } function askForReadOnly() { const context = this.context; // don't prompt if data is imported from a file if (context.useConfigurationFile) { return undefined; } const prompts = [ { type: 'confirm', name: 'readOnly', message: 'Is this entity read-only?', default: false, }, ]; return this.prompt(prompts).then(props => { this.entityConfig.readOnly = props.readOnly; }); } function askForDTO() { const context = this.context; // don't prompt if data is imported from a file or server is skipped or if no service layer if (context.useConfigurationFile || context.skipServer || this.entityConfig.service === 'no') { return undefined; } const prompts = [ { type: 'list', name: 'dto', message: 'Do you want to use a Data Transfer Object (DTO)?', choices: [ { value: NO_MAPPER, name: 'No, use the entity directly', }, { value: MAPSTRUCT, name: 'Yes, generate a DTO with MapStruct', }, ], default: 0, }, ]; return this.prompt(prompts).then(props => { this.entityConfig.dto = props.dto; }); } function askForService() { const context = this.context; // don't prompt if data is imported from a file or server is skipped if (context.useConfigurationFile || context.skipServer) { return undefined; } const prompts = [ { type: 'list', name: 'service', message: 'Do you want to use separate service class for your business logic?', choices: [ { value: NO_SERVICE, name: 'No, the REST controller should use the repository directly', }, { value: SERVICE_CLASS, name: 'Yes, generate a separate service class', }, { value: SERVICE_IMPL, name: 'Yes, generate a separate service interface and implementation', }, ], default: 0, }, ]; return this.prompt(prompts).then(props => { this.entityConfig.service = props.service; }); } function askForPagination() { const context = this.context; // don't prompt if data are imported from a file if (context.useConfigurationFile) { return undefined; } if (context.databaseType === CASSANDRA) { return undefined; } const prompts = [ { type: 'list', name: 'pagination', message: 'Do you want pagination and sorting on your entity?', choices: [ { value: NO_PAGINATION, name: 'No', }, { value: PAGINATION, name: 'Yes, with pagination links and sorting headers', }, { value: INFINITE_SCROLL, name: 'Yes, with infinite scroll and sorting headers', }, ], default: 0, }, ]; return this.prompt(prompts).then(props => { this.entityConfig.pagination = props.pagination; this.log(chalk.green('\nEverything is configured, generating the entity...\n')); }); } /** * ask question for a field creation */ function askForField() { const context = this.context; this.log(chalk.green(`\nGenerating field #${this.entityConfig.fields.length + 1}\n`)); const skipServer = context.skipServer; const prodDatabaseType = context.prodDatabaseType; const databaseType = context.databaseType; const clientFramework = context.clientFramework; const skipCheckLengthOfIdentifier = context.skipCheckLengthOfIdentifier; const possibleFiltering = databaseType === SQL && !context.reactive; const prompts = [ { type: 'confirm', name: 'fieldAdd', message: 'Do you want to add a field to your entity?', default: true, }, { when: response => response.fieldAdd === true, type: 'input', name: 'fieldName', validate: input => { if (!/^([a-zA-Z0-9_]*)$/.test(input)) { return 'Your field name cannot contain special characters'; } if (input === '') { return 'Your field name cannot be empty'; } if (input.charAt(0) === input.charAt(0).toUpperCase()) { return 'Your field name cannot start with an upper case letter'; } if (input === 'id' || getFieldNameUndercored(this.entityConfig.fields).includes(_.snakeCase(input))) { return 'Your field name cannot use an already existing field name'; } if ((clientFramework === undefined || clientFramework === ANGULAR) && isReservedFieldName(input, ANGULAR)) { return 'Your field name cannot contain a Java or Angular reserved keyword'; } if ((clientFramework !== undefined || clientFramework === REACT) && isReservedFieldName(input, REACT)) { return 'Your field name cannot contain a Java or React reserved keyword'; } if (prodDatabaseType === 'oracle' && input.length > 30 && !skipCheckLengthOfIdentifier) { return 'The field name cannot be of more than 30 characters'; } // we don't know, if filtering will be used if (possibleFiltering && isReservedPaginationWords(input)) { return 'Your field name cannot be a value, which is used as a parameter by Spring for pagination'; } return true; }, message: 'What is the name of your field?', }, { when: response => response.fieldAdd === true && (skipServer || ['sql', 'mongodb', 'neo4j', 'couchbase'].includes(databaseType)), type: 'list', name: 'fieldType', message: 'What is the type of your field?', choices: [ { value: STRING, name: 'String', }, { value: INTEGER, name: 'Integer', }, { value: LONG, name: 'Long', }, { value: FLOAT, name: 'Float', }, { value: DOUBLE, name: 'Double', }, { value: BIG_DECIMAL, name: 'BigDecimal', }, { value: LOCAL_DATE, name: 'LocalDate', }, { value: INSTANT, name: 'Instant', }, { value: ZONED_DATE_TIME, name: 'ZonedDateTime', }, { value: DURATION, name: 'Duration', }, { value: BOOLEAN, name: 'Boolean', }, { value: ENUM, name: 'Enumeration (Java enum type)', }, { value: UUID, name: 'UUID', }, { value: BYTES, name: '[BETA] Blob', }, ], default: 0, }, { when: response => { if (response.fieldType === ENUM) { response.fieldIsEnum = true; return true; } response.fieldIsEnum = false; return false; }, type: 'input', name: 'enumType', validate: input => { if (input === '') { return 'Your class name cannot be empty.'; } if (isReservedTableName(input, 'JAVA')) { return 'Your enum name cannot contain a Java reserved keyword'; } if (!/^[A-Za-z0-9_]*$/.test(input)) { return 'Your enum name cannot contain special characters (allowed characters: A-Z, a-z, 0-9 and _)'; } if (context.enums && context.enums.includes(input)) { context.existingEnum = true; } else if (context.enums) { context.enums.push(input); } else { context.enums = [input]; } return true; }, message: 'What is the class name of your enumeration?', }, { when: response => response.fieldIsEnum, type: 'input', name: 'fieldValues', validate: input => { if (input === '' && context.existingEnum) { context.existingEnum = false; return true; } if (input === '') { return 'You must specify values for your enumeration'; } // Commas allowed so that user can input a list of values split by commas. if (!/^[A-Za-z0-9_,]+$/.test(input)) { return 'Enum values cannot contain special characters (allowed characters: A-Z, a-z, 0-9 and _)'; } const enums = input.replace(/\s/g, '').split(','); if (_.uniq(enums).length !== enums.length) { return `Enum values cannot contain duplicates (typed values: ${input})`; } for (let i = 0; i < enums.length; i++) { if (/^[0-9].*/.test(enums[i])) { return `Enum value "${enums[i]}" cannot start with a number`; } if (enums[i] === '') { return 'Enum value cannot be empty (did you accidentally type "," twice in a row?)'; } } return true; }, message: answers => { if (!context.existingEnum) { return 'What are the values of your enumeration (separated by comma, no spaces)?'; } return 'What are the new values of your enumeration (separated by comma, no spaces)?\nThe new values will replace the old ones.\nNothing will be done if there are no new values.'; }, }, { when: response => response.fieldAdd === true && databaseType === CASSANDRA, type: 'list', name: 'fieldType', message: 'What is the type of your field?', choices: [ { value: UUID, name: 'UUID', }, { value: STRING, name: 'String', }, { value: INTEGER, name: 'Integer', }, { value: LONG, name: 'Long', }, { value: FLOAT, name: 'Float', }, { value: DOUBLE, name: 'Double', }, { value: BIG_DECIMAL, name: 'BigDecimal', }, { value: LOCAL_DATE, name: 'LocalDate', }, { value: INSTANT, name: 'Instant', }, { value: ZONED_DATE_TIME, name: 'ZonedDateTime', }, { value: DURATION, name: 'Duration', }, { value: ENUM, name: 'Enumeration (Java enum type)', }, { value: BOOLEAN, name: 'Boolean', }, { value: BYTE_BUFFER, name: '[BETA] blob', }, ], default: 0, }, { when: response => response.fieldAdd === true && response.fieldType === BYTES, type: 'list', name: 'fieldTypeBlobContent', message: 'What is the content of the Blob field?', choices: [ { value: IMAGE, name: 'An image', }, { value: ANY, name: 'A binary file', }, { value: TEXT, name: 'A CLOB (Text field)', }, ], default: 0, }, { when: response => response.fieldAdd === true && response.fieldType === BYTE_BUFFER, type: 'list', name: 'fieldTypeBlobContent', message: 'What is the content of the Blob field?', choices: [ { value: IMAGE, name: 'An image', }, { value: ANY, name: 'A binary file', }, ], default: 0, }, { when: response => response.fieldAdd === true && response.fieldType !== BYTE_BUFFER, type: 'confirm', name: 'fieldValidate', message: 'Do you want to add validation rules to your field?', default: false, }, { when: response => response.fieldAdd === true && response.fieldValidate === true, type: 'checkbox', name: 'fieldValidateRules', message: 'Which validation rules do you want to add?', choices: response => { // Default rules applicable for fieldType 'LocalDate', 'Instant', // 'ZonedDateTime', 'Duration', 'UUID', 'Boolean', 'ByteBuffer' and 'Enum' const opts = [ { name: 'Required', value: REQUIRED, }, { name: 'Unique', value: UNIQUE, }, ]; if (response.fieldType === STRING || response.fieldTypeBlobContent === TEXT) { opts.push( { name: 'Minimum length', value: MINLENGTH, }, { name: 'Maximum length', value: MAXLENGTH, }, { name: 'Regular expression pattern', value: PATTERN, } ); } else if ([INTEGER, LONG, FLOAT, DOUBLE, BIG_DECIMAL].includes(response.fieldType)) { opts.push( { name: 'Minimum', value: MIN, }, { name: 'Maximum', value: MAX, } ); } return opts; }, default: 0, }, { when: response => response.fieldAdd === true && response.fieldValidate === true && response.fieldValidateRules.includes('minlength'), type: 'input', name: 'fieldValidateRulesMinlength', validate: input => (this.isNumber(input) ? true : 'Minimum length must be a positive number'), message: 'What is the minimum length of your field?', default: 0, }, { when: response => response.fieldAdd === true && response.fieldValidate === true && response.fieldValidateRules.includes('maxlength'), type: 'input', name: 'fieldValidateRulesMaxlength', validate: input => (this.isNumber(input) ? true : 'Maximum length must be a positive number'), message: 'What is the maximum length of your field?', default: 20, }, { when: response => response.fieldAdd === true && response.fieldValidate === true && response.fieldValidateRules.includes('min'), type: 'input', name: 'fieldValidateRulesMin', message: 'What is the minimum of your field?', validate: (input, response) => { if ([FLOAT, DOUBLE, BIG_DECIMAL].includes(response.fieldType)) { return this.isSignedDecimalNumber(input) ? true : 'Minimum must be a decimal number'; } return this.isSignedNumber(input) ? true : 'Minimum must be a number'; }, default: 0, }, { when: response => response.fieldAdd === true && response.fieldValidate === true && response.fieldValidateRules.includes('max'), type: 'input', name: 'fieldValidateRulesMax', message: 'What is the maximum of your field?', validate: (input, response) => { if ([FLOAT, DOUBLE, BIG_DECIMAL].includes(response.fieldType)) { return this.isSignedDecimalNumber(input) ? true : 'Maximum must be a decimal number'; } return this.isSignedNumber(input) ? true : 'Maximum must be a number'; }, default: 100, }, { when: response => response.fieldAdd === true && response.fieldValidate === true && response.fieldValidateRules.includes(MINBYTES) && response.fieldType === BYTES && response.fieldTypeBlobContent !== TEXT, type: 'input', name: 'fieldValidateRulesMinbytes', message: 'What is the minimum byte size of your field?', validate: input => (this.isNumber(input) ? true : 'Minimum byte size must be a positive number'), default: 0, }, { when: response => response.fieldAdd === true && response.fieldValidate === true && response.fieldValidateRules.includes(MAXBYTES) && response.fieldType === BYTES && response.fieldTypeBlobContent !== TEXT, type: 'input', name: 'fieldValidateRulesMaxbytes', message: 'What is the maximum byte size of your field?', validate: input => (this.isNumber(input) ? true : 'Maximum byte size must be a positive number'), default: 5000000, }, { when: response => response.fieldAdd === true && response.fieldValidate === true && response.fieldValidateRules.includes('pattern'), type: 'input', name: 'fieldValidateRulesPattern', message: 'What is the regular expression pattern you want to apply on your field?', default: '^[a-zA-Z0-9]*$', }, ]; return this.prompt(prompts).then(props => { if (props.fieldAdd) { if (props.fieldIsEnum) { props.fieldType = _.upperFirst(props.fieldType); props.fieldValues = props.fieldValues.toUpperCase(); } const field = { fieldName: props.fieldName, fieldType: props.enumType || props.fieldType, fieldTypeBlobContent: props.fieldTypeBlobContent, fieldValues: props.fieldValues, fieldValidateRules: props.fieldValidateRules, fieldValidateRulesMinlength: props.fieldValidateRulesMinlength, fieldValidateRulesMaxlength: props.fieldValidateRulesMaxlength, fieldValidateRulesPattern: props.fieldValidateRulesPattern, fieldValidateRulesMin: props.fieldValidateRulesMin, fieldValidateRulesMax: props.fieldValidateRulesMax, fieldValidateRulesMinbytes: props.fieldValidateRulesMinbytes, fieldValidateRulesMaxbytes: props.fieldValidateRulesMaxbytes, }; this.entityConfig.fields = this.entityConfig.fields.concat(field); } logFieldsAndRelationships.call(this); if (props.fieldAdd) { return askForField.call(this); } return undefined; }); } /** * ask question for a relationship creation */ function askForRelationship() { const context = this.context; const name = context.name; this.log(chalk.green('\nGenerating relationships to other entities\n')); const prompts = [ { type: 'confirm', name: 'relationshipAdd', message: 'Do you want to add a relationship to another entity?', default: true, }, { when: response => response.relationshipAdd === true, type: 'input', name: 'otherEntityName', validate: input => { if (!/^([a-zA-Z0-9_]*)$/.test(input)) { return 'Your other entity name cannot contain special characters'; } if (input === '') { return 'Your other entity name cannot be empty'; } if (isReservedTableName(input, 'JAVA')) { return 'Your other entity name cannot contain a Java reserved keyword'; } if (input.toLowerCase() === 'user' && context.applicationType === 'microservice') { return "Your entity cannot have a relationship with User because it's a gateway entity"; } return true; }, message: 'What is the name of the other entity?', }, { when: response => response.relationshipAdd === true, type: 'input', name: 'relationshipName', validate: input => { if (!/^([a-zA-Z0-9_]*)$/.test(input)) { return 'Your relationship cannot contain special characters'; } if (input === '') { return 'Your relationship cannot be empty'; } if (input.charAt(0) === input.charAt(0).toUpperCase()) { return 'Your relationship cannot start with an upper case letter'; } if (input === 'id' || getFieldNameUndercored(this.entityConfig.fields).includes(_.snakeCase(input))) { return 'Your relationship cannot use an already existing field name'; } if (isReservedTableName(input, 'JAVA')) { return 'Your relationship cannot contain a Java reserved keyword'; } return true; }, message: 'What is the name of the relationship?', default: response => _.lowerFirst(response.otherEntityName), }, { when: response => response.relationshipAdd === true, type: 'list', name: 'relationshipType', message: 'What is the type of the relationship?', choices: response => { const opts = [ { value: 'many-to-one', name: 'many-to-one', }, { value: 'many-to-many', name: 'many-to-many', }, { value: 'one-to-one', name: 'one-to-one', }, ]; if (!this.isBuiltInUser(response.otherEntityName)) { opts.unshift({ value: 'one-to-many', name: 'one-to-many', }); } return opts; }, default: 0, }, { when: response => response.relationshipAdd === true && response.otherEntityName.toLowerCase() !== 'user' && (response.relationshipType === 'many-to-many' || response.relationshipType === 'one-to-one'), type: 'confirm', name: 'ownerSide', message: 'Is this entity the owner of the relationship?', default: false, }, { when: response => context.databaseType === SQL && response.relationshipAdd === true && response.relationshipType === 'one-to-one' && (response.ownerSide === true || response.otherEntityName.toLowerCase() === 'user'), type: 'confirm', name: 'id', message: 'Do you want to use JPA Derived Identifier - @MapsId?', default: false, }, { when: response => response.relationshipAdd === true && (response.relationshipType === 'one-to-many' || ((response.relationshipType === 'many-to-many' || response.relationshipType === 'one-to-one') && !this.isBuiltInUser(response.otherEntityName))), type: 'input', name: 'otherEntityRelationshipName', message: 'What is the name of this relationship in the other entity?', default: response => _.lowerFirst(name), }, { when: response => response.relationshipAdd === true && response.otherEntityName.toLowerCase() !== 'user' && (response.relationshipType === 'many-to-one' || (response.relationshipType === 'many-to-many' && response.ownerSide === true) || (response.relationshipType === 'one-to-one' && response.ownerSide === true)), type: 'input', name: 'otherEntityField', message: response => `When you display this relationship on client-side, which field from '${response.otherEntityName}' do you want to use? This field will be displayed as a String, so it cannot be a Blob`, default: 'id', }, { when: response => response.relationshipAdd === true && response.otherEntityName.toLowerCase() !== context.name.toLowerCase() && (response.relationshipType === 'many-to-one' || (response.relationshipType === 'many-to-many' && (response.ownerSide === true || response.otherEntityName.toLowerCase() === 'user')) || (response.relationshipType === 'one-to-one' && (response.ownerSide === true || response.otherEntityName.toLowerCase() === 'user'))), type: 'confirm', name: 'relationshipValidate', message: 'Do you want to add any validation rules to this relationship?', default: false, }, { when: response => response.relationshipValidate === true, type: 'checkbox', name: 'relationshipValidateRules', message: 'Which validation rules do you want to add?', choices: [ { name: 'Required', value: REQUIRED, }, ], default: 0, }, ]; return this.prompt(prompts).then(props => { if (props.relationshipAdd) { const relationship = { relationshipName: props.relationshipName, otherEntityName: _.lowerFirst(props.otherEntityName), relationshipType: props.relationshipType, relationshipValidateRules: props.relationshipValidateRules, otherEntityField: props.otherEntityField, ownerSide: props.ownerSide, id: props.id, otherEntityRelationshipName: props.otherEntityRelationshipName, }; if (props.otherEntityName.toLowerCase() === 'user') { relationship.ownerSide = true; relationship.otherEntityField = 'login'; relationship.otherEntityRelationshipName = _.lowerFirst(name); } this.entityConfig.relationships = this.entityConfig.relationships.concat(relationship); } logFieldsAndRelationships.call(this); if (props.relationshipAdd) { return askForRelationship.call(this); } this.log('\n'); return undefined; }); } /** * Show the entity and it's fields and relationships in console */ function logFieldsAndRelationships() { const context = this.context; if (this.entityConfig.fields.length > 0 || this.entityConfig.relationships.length > 0) { this.log(chalk.red(chalk.white('\n================= ') + context.name + chalk.white(' ================='))); } if (this.entityConfig.fields.length > 0) { this.log(chalk.white('Fields')); this.entityConfig.fields.forEach(field => { const validationDetails = []; const fieldValidate = _.isArray(field.fieldValidateRules) && field.fieldValidateRules.length >= 1; if (fieldValidate === true) { if (field.fieldValidateRules.includes(REQUIRED)) { validationDetails.push(REQUIRED); } if (field.fieldValidateRules.includes(UNIQUE)) { validationDetails.push(UNIQUE); } if (field.fieldValidateRules.includes(MINLENGTH)) { validationDetails.push(`${MINLENGTH}='${field.fieldValidateRulesMinlength}'`); } if (field.fieldValidateRules.includes(MAXLENGTH)) { validationDetails.push(`${MAXLENGTH}='${field.fieldValidateRulesMaxlength}'`); } if (field.fieldValidateRules.includes(PATTERN)) { validationDetails.push(`${PATTERN}='${field.fieldValidateRulesPattern}'`); } if (field.fieldValidateRules.includes(MIN)) { validationDetails.push(`${MIN}='${field.fieldValidateRulesMin}'`); } if (field.fieldValidateRules.includes(MAX)) { validationDetails.push(`${MAX}='${field.fieldValidateRulesMax}'`); } if (field.fieldValidateRules.includes(MINBYTES)) { validationDetails.push(`${MINBYTES}='${field.fieldValidateRulesMinbytes}'`); } if (field.fieldValidateRules.includes(MAXBYTES)) { validationDetails.push(`${MAXBYTES}='${field.fieldValidateRulesMaxbytes}'`); } } this.log( chalk.red(field.fieldName) + chalk.white(` (${field.fieldType}${field.fieldTypeBlobContent ? ` ${field.fieldTypeBlobContent}` : ''}) `) + chalk.cyan(validationDetails.join(' ')) ); }); this.log(); } if (this.entityConfig.relationships.length > 0) { this.log(chalk.white('Relationships')); this.entityConfig.relationships.forEach(relationship => { const validationDetails = []; if (relationship.relationshipValidateRules && relationship.relationshipValidateRules.includes(REQUIRED)) { validationDetails.push(REQUIRED); } this.log( `${chalk.red(relationship.relationshipName)} ${chalk.white(`(${_.upperFirst(relationship.otherEntityName)})`)} ${chalk.cyan( relationship.relationshipType )} ${chalk.cyan(validationDetails.join(' '))}` ); }); this.log(); } }