generator-jhipster 7.7.0 → 7.9.0

package/lib/support/base.cjs

@@ -0,0 +1,43 @@
+/**
+ * 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 { platform } = require('os');
+
+const isWin32 = platform() === 'win32';
+
+/**
+ * Converts multiples EditFileCallback callbacks into one.
+ *
+ * @param {...import('../../generators/generator-base.js').EditFileCallback} callbacks
+ * @returns {import('../../generators/generator-base.js').EditFileCallback}
+ */
+const joinCallbacks = (...callbacks) => {
+  return function (content, filePath) {
+    if (isWin32 && content.match(/\r\n/)) {
+      callbacks = [ct => ct.replace(/\r\n/g, '\n')].concat(callbacks).concat(ct => ct.replace(/\n/g, '\r\n'));
+    }
+    for (const callback of callbacks) {
+      content = callback.call(this, content, filePath);
+    }
+    return content;
+  };
+};
+
+module.exports = {
+  joinCallbacks,
+};

package/lib/support/needles.cjs

@@ -0,0 +1,221 @@
+/**
+ * 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 assert = require('assert');
+const chalk = require('chalk');
+const { kebabCase } = require('lodash');
+const escapeStringRegexp = require('escape-string-regexp');
+
+/**
+ * Change spaces sequences and '>' to allow any number of spaces or new line prefix
+ *
+ * @param {string} str string
+ * @returns {string} string where CRLF is replaced with LF in Windows
+ */
+const convertToPrettierExpressions = str => {
+  return str.replace(/\s+/g, '([\\s\n]*)').replace(/>+/g, '(\n?[\\s]*)>');
+};
+
+/**
+ * Check if contentToCheck existing in content
+ *
+ * @param {string} contentToCheck
+ * @param {string} content
+ * @param {boolean} [ignoreWhitespaces=true]
+ * @returns {boolean} if exists
+ */
+const checkContentIn = (contentToCheck, content, ignoreWhitespaces = true) => {
+  assert(content, 'content is required');
+  assert(contentToCheck, 'contentToCheck is required');
+
+  let re;
+  if (contentToCheck.test) {
+    re = contentToCheck;
+  } else if (ignoreWhitespaces) {
+    re = convertToPrettierExpressions(escapeStringRegexp(contentToCheck));
+  } else {
+    re = contentToCheck
+      .split('\n')
+      .map(line => `\\s*${escapeStringRegexp(line)}`)
+      .join('\n');
+  }
+  if (!re.test) {
+    re = new RegExp(re);
+  }
+  return re.test(content);
+};
+
+/**
+ * Write content before needle applying identation
+ *
+ * @param {object} args
+ * @param {string} args.content - normalized content
+ * @param {string} args.needle
+ * @param {string|string[]} args.contentToAdd
+ * @returns {string|null} null if needle was not found, new content otherwise
+ */
+const insertContentBeforeNeedle = ({ content, contentToAdd, needle }) => {
+  assert(needle, 'needle is required');
+  assert(content, 'content is required');
+  assert(contentToAdd, 'contentToAdd is required');
+
+  const regexp = new RegExp(`(?://|<!--|/*|#) jhipster-needle-${needle}(?:$|\n| )`, 'g');
+  const firstMatch = regexp.exec(content);
+  if (!firstMatch) {
+    return null;
+  }
+  if (regexp.exec(content)) {
+    throw new Error(`Multiple needles found for ${needle}`);
+  }
+
+  const needleIndex = firstMatch.index;
+
+  const needleLineIndex = content.lastIndexOf('\n', needleIndex);
+  const beforeContent = content.substring(0, needleLineIndex + 1);
+  const afterContent = content.substring(needleLineIndex + 1);
+
+  // Find needle ident
+  const needleLine = afterContent.split('\n', 2)[0];
+  const needleIdent = needleLine.length - needleLine.trimStart().length;
+
+  contentToAdd = []
+    .concat(contentToAdd)
+    .map(eachContentToAdd => eachContentToAdd.split('\n'))
+    .flat();
+
+  // Normalize needle ident with contentToAdd.
+  const firstContent = contentToAdd.find(line => line.trim());
+  const contentIdent = firstContent.length - firstContent.trimStart().length;
+  if (needleIdent > contentIdent) {
+    const identToApply = ' '.repeat(needleIdent - contentIdent);
+    contentToAdd = contentToAdd.map(line => (line ? identToApply + line : line));
+  } else if (needleIdent < contentIdent) {
+    let identToRemove = contentIdent - needleIdent;
+    contentToAdd
+      .filter(line => line.trimStart())
+      .forEach(line => {
+        const trimmedLine = line.trimStart();
+        const lineIdent = line.length - trimmedLine.length;
+        if (lineIdent < identToRemove) {
+          identToRemove = lineIdent;
+        }
+      });
+    contentToAdd = contentToAdd.map(line => (line.length > identToRemove ? line.substring(identToRemove) : ''));
+  }
+
+  return `${beforeContent}${contentToAdd.join('\n')}\n${afterContent}`;
+};
+
+/**
+ * Create an callback to insert the new content into existing content.
+ *
+ * @this Generator
+ * @param {object} options
+ * @param {string} options.needle needle to look for
+ * @param {string|string[]} options.contentToAdd content to add
+ * @param {boolean} [options.optional=false] don't throw error if needle was not found
+ * @param {boolean} [options.ignoreWhitespaces=true] check existing content ignoring white spaces and new lines
+ * @returns {import('../../generators/generator-base.js').EditFileCallback}
+ */
+const createNeedleCallback = ({ needle, contentToAdd, optional = false, ignoreWhitespaces = true }) => {
+  assert(needle, 'needle is required');
+  assert(contentToAdd, 'contentToAdd is required');
+
+  /**
+   * @type {import('../../generators/generator-base.js').EditFileCallback}
+   * @this {import('../../generators/generator-base.js')}
+   */
+  return function (content, filePath) {
+    contentToAdd = [].concat(contentToAdd).filter(eachContent => !checkContentIn(eachContent, content, ignoreWhitespaces));
+    if (contentToAdd.length === 0) {
+      return content;
+    }
+
+    const newContent = insertContentBeforeNeedle({
+      needle,
+      content,
+      contentToAdd,
+    });
+    if (newContent) {
+      return newContent;
+    }
+    const message = `Missing ${optional ? 'optional' : 'required'} jhipster-needle ${needle} not found at '${filePath}'`;
+    if (optional) {
+      this.log(chalk.yellow(message));
+      return content;
+    }
+    throw new Error(message);
+  };
+};
+
+/**
+ * Inject content before needle or create a needle insertion callback.
+ *
+ * @param {object} options foo
+ * @param {object} needles
+ * @param {string} options.contentToAdd content to add
+ * @param {Generator} [options.generator] generator if provided, editFile will be executed
+ * @param {string} [options.filePath] path to file
+ * @param {string} [options.needlesPrefix] common needle prefix
+ * @param {boolean} [options.optional=false] throw error if needle was not found
+ * @returns {import('../../generators/generator-base.js').CascatedEditFileCallback | import('../../generators/generator-base.js').EditFileCallback}
+ */
+const createBaseNeedle = (options, needles) => {
+  if (!needles) {
+    needles = options;
+    options = {};
+  }
+
+  assert(needles, 'needles is required');
+  const { generator, filePath, optional = false, ignoreWhitespaces = true } = options;
+  let { needlesPrefix } = options;
+  needlesPrefix = needlesPrefix ? `${needlesPrefix}-` : '';
+
+  const callbacks = Object.entries(needles)
+    .filter(([_key, contentToAdd]) => contentToAdd)
+    .map(([key, contentToAdd]) =>
+      createNeedleCallback({ needle: `${needlesPrefix}${kebabCase(key)}`, contentToAdd, optional, ignoreWhitespaces })
+    );
+
+  assert(callbacks.length > 0, 'At least 1 needle is required');
+
+  const callback =
+    callbacks.length === 1
+      ? callbacks[0]
+      : function (content, ...args) {
+          callbacks.forEach(cb => {
+            content = cb.call(this, content, ...args);
+          });
+          return content;
+        };
+
+  if (generator) {
+    assert(filePath, 'filePath is required');
+
+    return generator.editFile(filePath, callback);
+  }
+
+  return callback;
+};
+
+module.exports = {
+  checkContentIn,
+  insertContentBeforeNeedle,
+  createNeedleCallback,
+  createBaseNeedle,
+};

package/lib/support/shared-data.cjs

@@ -58,7 +58,7 @@ module.exports = class SharedData {
   /**
    * Get choices for a given config.
    * @param {String} configName
-   * @param {Any[]} defaultValueFallback
+   * @param {Any[]} choicesFallback
    * @returns {Any[]}
    */
   getConfigChoices(configName, choicesFallback) {
@@ -72,7 +72,7 @@ module.exports = class SharedData {
   /**
    * Set choices for a given config.
    * @param {String} configName
-   * @param {Any} defaultValue
+   * @param {Any} choices
    */
   setConfigChoices(configName, choices) {
     assert(configName, 'Config name is required');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "generator-jhipster",
-  "version": "7.7.0",
+  "version": "7.9.0",
   "description": "Spring Boot + Angular/React/Vue in one handy generator",
   "keywords": [
     "yeoman-generator",
@@ -84,58 +84,60 @@
   },
   "dependencies": {
     "@faker-js/faker": "5.5.3",
-    "aws-sdk": "2.1077.0",
-    "axios": "0.26.0",
+    "aws-sdk": "2.1185.0",
+    "axios": "0.27.2",
     "chalk": "4.1.2",
-    "chevrotain": "10.1.1",
-    "commander": "9.0.0",
-    "conf": "10.1.1",
-    "debug": "4.3.3",
+    "chevrotain": "10.1.2",
+    "commander": "9.4.0",
+    "conf": "10.2.0",
+    "debug": "4.3.4",
     "didyoumean": "1.2.2",
-    "ejs": "3.1.6",
-    "glob": "7.2.0",
+    "ejs": "3.1.8",
+    "escape-string-regexp": "4.0.0",
+    "glob": "8.0.3",
     "insight": "0.11.1",
     "js-yaml": "4.1.0",
     "lodash": "4.17.21",
     "mem-fs-editor": "9.4.0",
-    "minimatch": "5.0.0",
+    "minimatch": "5.1.0",
     "normalize-path": "3.0.0",
     "os-locale": "5.0.0",
     "p-queue": "6.6.2",
     "p-transform": "1.3.0",
-    "parse-gitignore": "1.0.1",
+    "parse-gitignore": "2.0.0",
     "pluralize": "8.0.0",
-    "prettier": "2.5.1",
-    "prettier-plugin-java": "1.6.1",
-    "prettier-plugin-packagejson": "2.2.15",
+    "prettier": "2.7.1",
+    "prettier-plugin-java": "1.6.2",
+    "prettier-plugin-packagejson": "2.2.18",
     "progress": "2.0.3",
     "randexp": "0.5.3",
-    "semver": "7.3.5",
+    "semver": "7.3.7",
     "shelljs": "0.8.5",
-    "simple-git": "3.2.6",
+    "simple-git": "3.11.0",
     "then-request": "6.0.2",
     "uuid": "8.3.2",
-    "winston": "3.6.0",
-    "yeoman-environment": "3.9.1",
-    "yeoman-generator": "5.6.1"
+    "winston": "3.8.1",
+    "yeoman-environment": "3.10.0",
+    "yeoman-generator": "5.7.0"
   },
   "devDependencies": {
     "chai": "4.3.6",
-    "ejs-lint": "1.2.1",
-    "eslint": "8.9.0",
+    "ejs-lint": "1.2.2",
+    "eslint": "8.20.0",
     "eslint-config-airbnb-base": "15.0.0",
-    "eslint-config-prettier": "8.4.0",
-    "eslint-plugin-chai-friendly": "^0.7.1",
-    "eslint-plugin-import": "2.25.4",
-    "eslint-plugin-mocha": "10.0.3",
-    "eslint-plugin-prettier": "4.0.0",
-    "expect": "27.5.1",
-    "fs-extra": "10.0.0",
-    "jsdoc": "3.6.10",
-    "mocha": "9.2.1",
-    "mocha-expect-snapshot": "3.1.0",
+    "eslint-config-prettier": "8.5.0",
+    "eslint-plugin-chai-friendly": "0.7.2",
+    "eslint-plugin-import": "2.26.0",
+    "eslint-plugin-mocha": "10.1.0",
+    "eslint-plugin-prettier": "4.2.1",
+    "expect": "28.1.3",
+    "fs-extra": "10.1.0",
+    "jest-mock": "28.1.3",
+    "jsdoc": "3.6.11",
+    "mocha": "9.2.2",
+    "mocha-expect-snapshot": "4.0.0",
     "proxyquire": "2.1.3",
-    "sinon": "13.0.1",
+    "sinon": "14.0.0",
     "sinon-chai": "3.7.0",
     "sort-keys": "4.2.0",
     "yeoman-assert": "3.1.1",

package/utils/blueprint.js

@@ -69,7 +69,7 @@ function parseBluePrints(blueprints) {
 /**
  * @private
  * Merges blueprint arrays, keeping order and version priority.
- * @param {...Blueprint[]} blueprints - Blueprint arrays to be merged.
+ * @param {...Blueprint[]} blueprintsToMerge - Blueprint arrays to be merged.
  * @returns {Blueprint[]} an array that contains the info for each blueprint
  */
 function mergeBlueprints(...blueprintsToMerge) {

package/utils/entity.js

@@ -47,8 +47,11 @@ const BASE_TEMPLATE_DATA = {
   haveFieldWithJavadoc: false,
   existingEnum: false,
   searchEngine: false,
+  microserviceName: undefined,
 
+  requiresPersistableImplementation: false,
   fieldsContainDate: false,
+  fieldsContainTimed: false,
   fieldsContainInstant: false,
   fieldsContainUUID: false,
   fieldsContainZonedDateTime: false,
@@ -211,7 +214,7 @@ function prepareEntityForTemplates(entityWithConfig, generator) {
   const { microserviceName, entityFileName, microfrontend } = entityWithConfig;
   entityWithConfig.entityApi = microserviceName ? `services/${microserviceName.toLowerCase()}/` : '';
   entityWithConfig.entityPage =
-    microfrontend && microserviceName && (entityWithConfig.applicationType === MICROSERVICE || entityWithConfig.applicationType === GATEWAY)
+    microfrontend && microserviceName && entityWithConfig.applicationType === MICROSERVICE
       ? `${microserviceName.toLowerCase()}/${entityFileName}`
       : `${entityFileName}`;
 
@@ -473,9 +476,16 @@ function loadRequiredConfigIntoEntity(entity, config) {
     authenticationType: config.authenticationType,
     reactive: config.reactive,
     microfrontend: config.microfrontend,
+    packageName: config.packageName,
+    packageFolder: config.packageFolder,
     // Workaround different paths
     clientFramework: config.clientFramework,
   });
+  if (config.applicationType === MICROSERVICE) {
+    _.defaults(entity, {
+      microserviceName: config.baseName,
+    });
+  }
   return entity;
 }
 

package/utils/field.js

@@ -93,6 +93,13 @@ const fakeStringTemplateForFieldName = columnName => {
   return `{{${fakeTemplate}}}`;
 };
 
+/**
+ * @param {*} field
+ * @param {*} faker
+ * @param {*} changelogDate
+ * @param {string} type csv, cypress, json-serializable, ts
+ * @returns fake value
+ */
 const generateFakeDataForField = (field, faker, changelogDate, type = 'csv') => {
   let data;
   if (field.fakerTemplate) {
@@ -140,7 +147,7 @@ const generateFakeDataForField = (field, faker, changelogDate, type = 'csv') =>
       // See https://stackoverflow.com/a/34053802/150868
       // YYYY-MM-DDTHH:mm:ss
       data = isoDate.split('.')[0];
-      if (type === 'cypress') {
+      if (type === 'cypress' || type === 'ts') {
         // YYYY-MM-DDTHH:mm
         data = data.substr(0, data.length - 3);
       }
@@ -240,11 +247,12 @@ function _derivedProperties(field) {
 
 function prepareFieldForTemplates(entityWithConfig, field, generator) {
   _.defaults(field, {
+    propertyName: field.fieldName,
     fieldNameCapitalized: _.upperFirst(field.fieldName),
     fieldNameUnderscored: _.snakeCase(field.fieldName),
     fieldNameHumanized: _.startCase(field.fieldName),
     fieldTranslationKey: `${entityWithConfig.i18nKeyPrefix}.${field.fieldName}`,
-    tsType: generator.getTypescriptKeyType(field.fieldType),
+    tsType: generator.getTypescriptType(field.fieldType),
     entity: entityWithConfig,
   });
   const fieldType = field.fieldType;
@@ -270,23 +278,27 @@ function prepareFieldForTemplates(entityWithConfig, field, generator) {
       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 = true;
+      field.liquibaseAutoIncrement = field.fieldType === LONG;
       field.jpaGeneratedValue = false;
-      field.autoGenerateByService = false;
-      field.autoGenerateByRepository = true;
+      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 || field.fieldType === LONG ? defaultGenerationType : true;
       field.autoGenerateByService = false;
       field.autoGenerateByRepository = true;
+      field.requiresPersistableImplementation = false;
       field.readonly = true;
       if (field.jpaGeneratedValue === 'identity') {
         field.liquibaseAutoIncrement = true;
@@ -295,6 +307,10 @@ function prepareFieldForTemplates(entityWithConfig, field, generator) {
   }
 
   field.fieldIsEnum = !field.id && fieldIsEnum(fieldType);
+  if (field.fieldIsEnum) {
+    field.enumFileName = _.kebabCase(field.fieldType);
+  }
+
   field.fieldWithContentType = (fieldType === BYTES || fieldType === BYTE_BUFFER) && field.fieldTypeBlobContent !== TEXT;
   if (field.fieldWithContentType) {
     field.contentTypeFieldName = `${field.fieldName}ContentType`;
@@ -343,7 +359,7 @@ function prepareFieldForTemplates(entityWithConfig, field, generator) {
   field.generateFakeData = (type = 'csv') => {
     let data = generateFakeDataForField(field, faker, entityWithConfig.changelogDateForRecent, type);
     // manage uniqueness
-    if (field.fieldValidate === true && field.fieldValidateRules.includes(UNIQUE)) {
+    if ((field.fieldValidate === true && field.fieldValidateRules.includes(UNIQUE)) || field.id) {
       let i = 0;
       while (field.uniqueValue.indexOf(data) !== -1) {
         if (i++ === 5) {
@@ -384,6 +400,10 @@ function fieldIsEnum(fieldType) {
     BOOLEAN,
     BYTES,
     BYTE_BUFFER,
+    ANY_BLOB,
+    BLOB,
+    IMAGE_BLOB,
+    TEXT_BLOB,
   ].includes(fieldType);
 }
 

package/utils/liquibase.js

@@ -19,7 +19,7 @@
 
 const _ = require('lodash');
 
-const { MYSQL, MARIADB, POSTGRESQL } = require('../jdl/jhipster/database-types');
+const { MYSQL, MARIADB } = require('../jdl/jhipster/database-types');
 const { CommonDBTypes, RelationalOnlyDBTypes, BlobTypes } = require('../jdl/jhipster/field-types');
 
 const { STRING, INTEGER, LONG, BIG_DECIMAL, FLOAT, DOUBLE, UUID, BOOLEAN, LOCAL_DATE, ZONED_DATE_TIME, INSTANT, DURATION } = CommonDBTypes;
@@ -129,12 +129,8 @@ function parseLiquibaseColumnType(entity, field) {
   }
 
   if (fieldType === BYTES && field.fieldTypeBlobContent !== TEXT) {
-    const { prodDatabaseType } = entity;
-    if (prodDatabaseType === MYSQL || prodDatabaseType === POSTGRESQL || prodDatabaseType === MARIADB) {
-      return 'longblob';
-    }
-
-    return 'blob';
+    // eslint-disable-next-line no-template-curly-in-string
+    return '${blobType}';
   }
 
   if (field.fieldTypeBlobContent === TEXT) {
@@ -169,7 +165,8 @@ function parseLiquibaseLoadColumnType(entity, field) {
     return columnType;
   }
 
-  if (columnType === 'blob' || columnType === 'longblob') {
+  // eslint-disable-next-line no-template-curly-in-string
+  if (columnType === '${blobType}') {
     return 'blob';
   }
 

package/utils/relationship.js

@@ -21,7 +21,7 @@ const _ = require('lodash');
 const pluralize = require('pluralize');
 const { isReservedTableName } = require('../jdl/jhipster/reserved-keywords');
 const { stringify } = require('.');
-const { NEO4J } = require('../jdl/jhipster/database-types');
+const { NEO4J, NO: DATABASE_NO } = require('../jdl/jhipster/database-types');
 const { MapperTypes } = require('../jdl/jhipster/entity-options');
 const { REQUIRED } = require('../jdl/jhipster/validations');
 
@@ -71,7 +71,12 @@ function prepareRelationshipForTemplates(entityWithConfig, relationship, generat
         }
         return otherSideRelationship.relationshipName === relationship.otherEntityRelationshipName;
       });
-      if (
+      if (!otherRelationship) {
+        // TODO throw error at v8.
+        generator.warning(
+          `Error at '${entityName}' definitions: 'otherEntityRelationshipName' is set with value '${relationship.otherEntityRelationshipName}' at relationship '${relationship.relationshipName}' but no back-reference was found at '${otherEntityName}'`
+        );
+      } else if (
         otherRelationship &&
         otherRelationship.otherEntityRelationshipName &&
         otherRelationship.otherEntityRelationshipName !== relationship.relationshipName
@@ -116,7 +121,8 @@ function prepareRelationshipForTemplates(entityWithConfig, relationship, generat
       });
     } else if (
       !ignoreMissingRequiredRelationship &&
-      generator.jhipsterConfig.databaseType !== NEO4J &&
+      entityWithConfig.databaseType !== NEO4J &&
+      entityWithConfig.databaseType !== DATABASE_NO &&
       (relationship.relationshipType === 'one-to-many' || relationship.ownerSide === false)
     ) {
       throw new Error(`Error at entity ${entityName}: could not find the other side of the relationship ${stringify(relationship)}`);
@@ -176,6 +182,10 @@ function prepareRelationshipForTemplates(entityWithConfig, relationship, generat
     otherEntityNameCapitalizedPlural: pluralize(relationship.otherEntityNameCapitalized),
   });
 
+  _.defaults(relationship, {
+    propertyName: relationship.collection ? relationship.relationshipFieldNamePlural : relationship.relationshipFieldName,
+  });
+
   if (entityWithConfig.dto === MAPSTRUCT) {
     if (otherEntityData.dto !== MAPSTRUCT && !generator.isBuiltInUser(otherEntityName)) {
       generator.warning(

package/generators/client/templates/react/src/main/webapp/app/shared/error/error-boundary-route.spec.tsx.ejs

@@ -1,33 +0,0 @@
-import React from 'react';
-import { Router } from 'react-router-dom';
-import { createMemoryHistory } from 'history';
-import { render } from '@testing-library/react';
-
-import ErrorBoundaryRoute from './error-boundary-route';
-
-const ErrorComp = () => {
-  throw new Error('test');
-};
-
-describe('error-boundary-route component', () => {
-  beforeEach(() => {
-    // ignore console and jsdom errors
-    jest.spyOn((window as any)._virtualConsole, 'emit').mockImplementation(() => false);
-    jest.spyOn((window as any).console, 'error').mockImplementation(() => false);
-  });
-
-  // All tests will go here
-  it('Should throw error when no component is provided', () => {
-    expect(() => render(<ErrorBoundaryRoute />)).toThrow(Error);
-  });
-
-  it('Should render fallback component when an uncaught error is thrown from component', () => {
-    const history = createMemoryHistory();
-    const { container } = render(
-      <Router history={history}>
-        <ErrorBoundaryRoute component={ErrorComp} path="/" />
-      </Router>
-    );
-    expect(container.innerHTML).toEqual('<div><h2 class="error">An unexpected error has occurred.</h2></div>');
-  });
-});

package/generators/client/templates/react/src/main/webapp/app/shared/error/error-boundary-route.tsx.ejs

@@ -1,17 +0,0 @@
-import React from 'react';
-import { Route, RouteProps } from 'react-router-dom';
-import ErrorBoundary from 'app/shared/error/error-boundary';
-
-export const ErrorBoundaryRoute = ({ component: Component, ...rest }: RouteProps) => {
-  const encloseInErrorBoundary = props => (
-    <ErrorBoundary>
-      <Component {...props} />
-    </ErrorBoundary>
-  );
-
-  if (!Component) throw new Error(`A component needs to be specified for path ${(rest as any).path}`);
-
-  return <Route {...rest} render={encloseInErrorBoundary} />;
-};
-
-export default ErrorBoundaryRoute;