generator-jhipster 8.0.0 → 8.2.0

package/dist/generators/server/support/prepare-field.js

@@ -0,0 +1,159 @@
+/**
+ * Copyright 2013-2024 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.
+ */
+import assert from 'assert';
+import * as _ from 'lodash-es';
+import { databaseTypes, entityOptions, fieldTypes, reservedKeywords } from '../../../jdl/jhipster/index.js';
+import { getUXConstraintName } from './database.js';
+import { getJavaValueGeneratorForType } from './templates/field-values.js';
+import { formatDocAsApiDescription, formatDocAsJavaDoc } from '../../java/support/doc.js';
+const { isReservedTableName } = reservedKeywords;
+const { CommonDBTypes } = fieldTypes;
+const { MYSQL, SQL } = databaseTypes;
+const { MapperTypes } = entityOptions;
+const { MAPSTRUCT } = MapperTypes;
+const { INTEGER, LONG, UUID } = CommonDBTypes;
+const { snakeCase, upperFirst } = _;
+export default function prepareField(entityWithConfig, field, generator) {
+    if (field.mapstructExpression) {
+        assert.equal(entityWithConfig.dto, MAPSTRUCT, `@MapstructExpression requires an Entity with mapstruct dto [${entityWithConfig.name}.${field.fieldName}].`);
+        // Remove from Entity.java and liquibase.
+        field.transient = true;
+        // Disable update form.
+        field.readonly = true;
+    }
+    if (field.documentation) {
+        field.fieldJavadoc = formatDocAsJavaDoc(field.documentation, 4);
+        field.fieldApiDescription = formatDocAsApiDescription(field.documentation);
+    }
+    if (field.id && entityWithConfig.primaryKey) {
+        if (field.autoGenerate === undefined) {
+            field.autoGenerate = !entityWithConfig.primaryKey.composite && [INTEGER, LONG, UUID].includes(field.fieldType);
+        }
+        if (!field.autoGenerate) {
+            field.liquibaseAutoIncrement = false;
+            field.jpaGeneratedValue = false;
+            field.autoGenerateByService = false;
+            field.autoGenerateByRepository = false;
+            field.requiresPersistableImplementation = true;
+        }
+        else if (entityWithConfig.databaseType !== SQL) {
+            field.liquibaseAutoIncrement = false;
+            field.jpaGeneratedValue = false;
+            field.autoGenerateByService = field.fieldType === UUID;
+            field.autoGenerateByRepository = !field.autoGenerateByService;
+            field.requiresPersistableImplementation = false;
+            field.readonly = true;
+        }
+        else if (entityWithConfig.reactive) {
+            field.liquibaseAutoIncrement = field.fieldType === LONG;
+            field.jpaGeneratedValue = false;
+            field.autoGenerateByService = !field.liquibaseAutoIncrement;
+            field.autoGenerateByRepository = !field.autoGenerateByService;
+            field.requiresPersistableImplementation = !field.liquibaseAutoIncrement;
+            field.readonly = true;
+        }
+        else {
+            const defaultGenerationType = entityWithConfig.prodDatabaseType === MYSQL ? 'identity' : 'sequence';
+            field.jpaGeneratedValue = field.jpaGeneratedValue || [INTEGER, LONG].includes(field.fieldType) ? defaultGenerationType : true;
+            field.jpaGeneratedValueSequence = field.jpaGeneratedValue === 'sequence';
+            field.jpaGeneratedValueIdentity = field.jpaGeneratedValue === 'identity';
+            field.autoGenerateByService = false;
+            field.autoGenerateByRepository = true;
+            field.requiresPersistableImplementation = false;
+            field.readonly = true;
+            if (field.jpaGeneratedValueIdentity) {
+                field.liquibaseAutoIncrement = true;
+            }
+            else if (field.jpaGeneratedValueSequence) {
+                field.jpaSequenceGeneratorName = field.sequenceGeneratorName ?? 'sequenceGenerator';
+                field.liquibaseSequenceGeneratorName = snakeCase(field.jpaSequenceGeneratorName);
+                field.liquibaseCustomSequenceGenerator = field.liquibaseSequenceGeneratorName !== 'sequence_generator';
+            }
+        }
+    }
+    if (field.fieldNameAsDatabaseColumn === undefined) {
+        const fieldNameUnderscored = snakeCase(field.fieldName);
+        const jhiFieldNamePrefix = entityWithConfig.jhiTablePrefix;
+        if (isReservedTableName(fieldNameUnderscored, entityWithConfig.prodDatabaseType ?? entityWithConfig.databaseType)) {
+            if (!jhiFieldNamePrefix) {
+                generator.log.warn(`The field name '${fieldNameUnderscored}' is regarded as a reserved keyword, but you have defined an empty jhiPrefix. This might lead to a non-working application.`);
+                field.fieldNameAsDatabaseColumn = fieldNameUnderscored;
+            }
+            else {
+                field.fieldNameAsDatabaseColumn = `${jhiFieldNamePrefix}_${fieldNameUnderscored}`;
+            }
+        }
+        else {
+            field.fieldNameAsDatabaseColumn = fieldNameUnderscored;
+        }
+    }
+    field.columnName = field.fieldNameAsDatabaseColumn;
+    if (field.unique) {
+        field.uniqueConstraintName = getUXConstraintName(entityWithConfig.entityTableName, field.columnName, {
+            prodDatabaseType: entityWithConfig.prodDatabaseType,
+        }).value;
+    }
+    if (field.fieldInJavaBeanMethod === undefined) {
+        // Handle the specific case when the second letter is capitalized
+        // See http://stackoverflow.com/questions/2948083/naming-convention-for-getters-setters-in-java
+        if (field.fieldName.length > 1) {
+            const firstLetter = field.fieldName.charAt(0);
+            const secondLetter = field.fieldName.charAt(1);
+            if (firstLetter === firstLetter.toLowerCase() && secondLetter === secondLetter.toUpperCase()) {
+                field.fieldInJavaBeanMethod = firstLetter.toLowerCase() + field.fieldName.slice(1);
+            }
+            else {
+                field.fieldInJavaBeanMethod = upperFirst(field.fieldName);
+            }
+        }
+        else {
+            field.fieldInJavaBeanMethod = upperFirst(field.fieldName);
+        }
+    }
+    if (field.fieldValidateRulesPatternJava === undefined) {
+        field.fieldValidateRulesPatternJava = field.fieldValidateRulesPattern
+            ? field.fieldValidateRulesPattern.replace(/\\/g, '\\\\').replace(/"/g, '\\"')
+            : field.fieldValidateRulesPattern;
+    }
+    if (field.blobContentTypeText) {
+        field.javaFieldType = 'String';
+    }
+    else {
+        field.javaFieldType = field.fieldType;
+    }
+    if (field.fieldTypeInteger || field.fieldTypeLong || field.fieldTypeString || field.fieldTypeUUID) {
+        if (field.fieldTypeInteger) {
+            field.javaValueSample1 = '1';
+            field.javaValueSample2 = '2';
+        }
+        else if (field.fieldTypeLong) {
+            field.javaValueSample1 = '1L';
+            field.javaValueSample2 = '2L';
+        }
+        else if (field.fieldTypeString) {
+            field.javaValueSample1 = `"${field.fieldName}1"`;
+            field.javaValueSample2 = `"${field.fieldName}2"`;
+        }
+        else if (field.fieldTypeUUID) {
+            field.javaValueSample1 = 'UUID.fromString("23d8dc04-a48b-45d9-a01d-4b728f0ad4aa")';
+            field.javaValueSample2 = 'UUID.fromString("ad79f240-3727-46c3-b89f-2cf6ebd74367")';
+        }
+        field.javaValueGenerator = getJavaValueGeneratorForType(field.javaFieldType);
+    }
+}

package/dist/generators/server/support/prepare-relationship.js

@@ -0,0 +1,7 @@
+import { formatDocAsApiDescription, formatDocAsJavaDoc } from '../../java/support/doc.js';
+export function prepareRelationship({ relationship }) {
+    if (relationship.documentation) {
+        relationship.relationshipJavadoc = formatDocAsJavaDoc(relationship.documentation, 4);
+        relationship.relationshipApiDescription = formatDocAsApiDescription(relationship.documentation);
+    }
+}

package/dist/generators/server/support/relationship.js

@@ -0,0 +1,41 @@
+/**
+ * Copyright 2013-2024 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.
+ */
+import { addOtherRelationship } from '../../base-application/support/index.js';
+// eslint-disable-next-line import/prefer-default-export
+export const addEntitiesOtherRelationships = (entities) => {
+    const result = { warning: [] };
+    for (const entity of entities.filter(entity => !entity.builtIn)) {
+        for (const relationship of entity.relationships ?? []) {
+            if (!relationship.otherRelationship &&
+                (relationship.otherEntityRelationshipName ||
+                    relationship.relationshipType === 'many-to-many' ||
+                    // OneToOne back reference is required due to filtering
+                    (relationship.relationshipType === 'one-to-one' && entity.databaseType === 'sql') ||
+                    (relationship.relationshipType === 'one-to-many' && entity.databaseType !== 'neo4j' && entity.databaseType !== 'no'))) {
+                if (relationship.otherEntity.builtIn) {
+                    result.warning.push(`Ignoring '${entity.name}' definitions as it is using a built-in Entity '${relationship.otherEntityName}': 'otherEntityRelationshipName' is set with value '${relationship.otherEntityRelationshipName}' at relationship '${relationship.relationshipName}' but no back-reference was found`);
+                }
+                else {
+                    relationship.otherRelationship = addOtherRelationship(entity, relationship.otherEntity, relationship);
+                }
+            }
+        }
+    }
+    return result;
+};

package/dist/generators/server/support/spring-factories.js

@@ -0,0 +1,12 @@
+import properties from 'dot-properties';
+// eslint-disable-next-line import/prefer-default-export
+export const addSpringFactory = ({ key, value }) => content => {
+    const obj = properties.parse(content ?? '');
+    const oldContent = obj[key];
+    const factories = (oldContent?.split(',') ?? []).map(val => val.trim());
+    if (factories.includes(value)) {
+        return content;
+    }
+    obj[key] = [...factories, value].join(',');
+    return properties.stringify(obj);
+};

package/dist/generators/server/support/string.js

@@ -0,0 +1,49 @@
+/**
+ * Copyright 2013-2024 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.
+ */
+/**
+ * get hibernate SnakeCase in JHipster preferred style.
+ *
+ * @param {string} value - table column name or table name string
+ * @see org.springframework.boot.orm.jpa.hibernate.SpringNamingStrategy
+ * @returns hibernate SnakeCase in JHipster preferred style
+ */
+// eslint-disable-next-line import/prefer-default-export
+export function hibernateSnakeCase(value) {
+    let res = '';
+    if (value) {
+        if (value.length === 1) {
+            return value.toLowerCase();
+        }
+        value = value.replace('.', '_');
+        res = value[0];
+        for (let i = 1, len = value.length - 1; i < len; i++) {
+            if (value[i - 1] !== value[i - 1].toUpperCase() &&
+                value[i] !== value[i].toLowerCase() &&
+                value[i + 1] !== value[i + 1].toUpperCase()) {
+                res += `_${value[i]}`;
+            }
+            else {
+                res += value[i];
+            }
+        }
+        res += value[value.length - 1];
+        res = res.toLowerCase();
+    }
+    return res;
+}

package/dist/generators/server/support/templates/field-values.js

@@ -0,0 +1,67 @@
+/**
+ * Copyright 2013-2024 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.
+ */
+import { fieldTypes, databaseTypes } from '../../../../jdl/jhipster/index.js';
+const dbTypes = fieldTypes;
+const { STRING, UUID, LONG, INTEGER } = dbTypes.CommonDBTypes;
+const { SQL } = databaseTypes;
+/**
+ * Returns the java value generator for the given primaryKey type
+ */
+export const getJavaValueGeneratorForType = (type) => {
+    if (type === STRING) {
+        return 'UUID.randomUUID().toString()';
+    }
+    if (type === UUID) {
+        return 'UUID.randomUUID()';
+    }
+    if (type === INTEGER) {
+        return 'intCount.incrementAndGet()';
+    }
+    if (type === LONG) {
+        return 'longCount.incrementAndGet()';
+    }
+    throw new Error(`Java type ${type} does not have a random generator implemented`);
+};
+/**
+ * @private
+ * Returns the primary key value based on the primary key type, DB and default value
+ *
+ * @param {string} primaryKey - the primary key type
+ * @param {string} databaseType - the database type
+ * @param {number} defaultValue - default value
+ * @returns {string} java primary key value
+ */
+export const getPrimaryKeyValue = (primaryKey, databaseType, defaultValue = 1) => {
+    if (typeof primaryKey === 'object' && primaryKey.composite) {
+        return `new ${primaryKey.type}(${primaryKey.references
+            .map(ref => getPrimaryKeyValue(ref.type, databaseType, defaultValue))
+            .join(', ')})`;
+    }
+    const primaryKeyType = typeof primaryKey === 'string' ? primaryKey : primaryKey.type;
+    if (primaryKeyType === STRING) {
+        if (databaseType === SQL && defaultValue === 0) {
+            return getJavaValueGeneratorForType(primaryKeyType);
+        }
+        return `"id${defaultValue}"`;
+    }
+    if (primaryKeyType === UUID) {
+        return getJavaValueGeneratorForType(primaryKeyType);
+    }
+    return `${defaultValue}L`;
+};

package/dist/generators/server/support/update-languages.js

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2013-2024 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.
+ */
+/**
+ * Update Languages In MailServiceIT
+ *
+ * @param application
+ */
+export function updateLanguagesInMailServiceITTask({ application, control }) {
+    const { javaPackageTestDir, languagesDefinition } = application;
+    const { ignoreNeedlesError: ignoreNonExisting } = control;
+    let newContent = 'private static final String[] languages = {\n';
+    languagesDefinition?.forEach((language, i) => {
+        newContent += `        "${language.languageTag}"${i !== languagesDefinition.length - 1 ? ',' : ''}\n`;
+    });
+    newContent += '        // jhipster-needle-i18n-language-constant - JHipster will add/remove languages in this array\n    };';
+    this.editFile(`${javaPackageTestDir}/service/MailServiceIT.java`, { ignoreNonExisting }, content => content.replace(/private.*static.*String.*languages.*\{([^}]*jhipster-needle-i18n-language-constant[^}]*)\};/g, newContent));
+}
+export default function updateLanguagesTask(taskParam) {
+    updateLanguagesInMailServiceITTask.call(this, taskParam);
+}

package/dist/generators/server/templates/README.md.jhi.spring-boot.ejs

@@ -1,5 +1,5 @@
 <%#
- Copyright 2013-2023 the original author or authors from the JHipster project.
+ Copyright 2013-2024 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.
@@ -24,6 +24,9 @@
   <%_ if (applicationTypeGateway || applicationTypeMicroservice) { _%>
 
 This is a "<%= applicationType %>" application intended to be part of a microservice architecture, please refer to the [Doing microservices with JHipster][] page of the documentation for more information.
+  <%_ } _%>
+  <%_ if (serviceDiscoveryAny) { _%>
+
 This application is configured for Service Discovery and Configuration with <% if (serviceDiscoveryEureka) { %>the JHipster-Registry<% } %><% if (serviceDiscoveryConsul) { %>Consul<% } %>. On launch, it will refuse to start if it is not able to connect to <% if (serviceDiscoveryEureka) { %>the JHipster-Registry at [http://localhost:8761](http://localhost:8761)<% } %><% if (serviceDiscoveryConsul) { %>Consul at [http://localhost:8500](http://localhost:8500)<% } %>.<% if (serviceDiscoveryEureka) { %> For more information, read our documentation on [Service Discovery and Configuration with the JHipster-Registry][].<% } %><% if (serviceDiscoveryConsul) { %> For more information, read our documentation on [Service Discovery and Configuration with Consul][].<% } %>
   <%_ } _%>
 
@@ -41,7 +44,7 @@ In the project root, JHipster generates configuration files for tools like git,
 - `.yo-rc.json` - Yeoman configuration file
 JHipster configuration is stored in this file at `generator-jhipster` key. You may find `generator-jhipster-*` for specific blueprints configuration.
 - `.yo-resolve` (optional) - Yeoman conflict resolver
-Allows to use a specific action when conflicts are found skipping prompts for files that matches a pattern. Each line should match `[pattern] [action]` with pattern been a [Minimatch](https://github.com/isaacs/minimatch#minimatch) pattern and action been one of skip (default if ommited) or force. Lines starting with `#` are considered comments and are ignored.
+Allows to use a specific action when conflicts are found skipping prompts for files that matches a pattern. Each line should match `[pattern] [action]` with pattern been a [Minimatch](https://github.com/isaacs/minimatch#minimatch) pattern and action been one of skip (default if omitted) or force. Lines starting with `#` are considered comments and are ignored.
 - `.jhipster/*.json` - JHipster entity configuration files
   <%_ if (!skipClient) { %>
 - `npmw` - wrapper to use locally installed npm.