generator-jhipster 8.2.0 → 8.2.1

package/dist/generators/base-application/support/prepare-field.mjs

@@ -1,389 +0,0 @@
-/**
- * Copyright 2013-2023 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 * as _ from 'lodash-es';
-import { fieldTypes, validations } from '../../../jdl/jhipster/index.mjs';
-import { getTypescriptType, prepareField as prepareClientFieldForTemplates } from '../../client/support/index.mjs';
-import { prepareField as prepareServerFieldForTemplates } from '../../server/support/index.mjs';
-import { fieldIsEnum } from './field-utils.mjs';
-import { mutateData } from '../../base/support/config.mjs';
-const { BlobTypes, CommonDBTypes, RelationalOnlyDBTypes } = fieldTypes;
-const { Validations: { MIN, MINLENGTH, MINBYTES, MAX, MAXBYTES, MAXLENGTH, PATTERN, REQUIRED, UNIQUE }, } = validations;
-const { TEXT, IMAGE, ANY } = BlobTypes;
-const { BOOLEAN, BIG_DECIMAL, DOUBLE, DURATION, FLOAT, INSTANT, INTEGER, LOCAL_DATE, LONG, STRING, UUID, ZONED_DATE_TIME, IMAGE_BLOB, ANY_BLOB, TEXT_BLOB, BLOB, } = CommonDBTypes;
-const { BYTES, BYTE_BUFFER } = RelationalOnlyDBTypes;
-const fakeStringTemplateForFieldName = columnName => {
-    let fakeTemplate;
-    if (columnName === 'first_name') {
-        fakeTemplate = 'person.firstName';
-    }
-    else if (columnName === 'last_name') {
-        fakeTemplate = 'person.lastName';
-    }
-    else if (columnName === 'job_title') {
-        fakeTemplate = 'person.jobTitle';
-    }
-    else if (columnName === 'telephone' || columnName === 'phone') {
-        fakeTemplate = 'phone.number';
-    }
-    else if (columnName === 'zip_code' || columnName === 'post_code') {
-        fakeTemplate = 'location.zipCode';
-    }
-    else if (columnName === 'city') {
-        fakeTemplate = 'location.city';
-    }
-    else if (columnName === 'street_name' || columnName === 'street') {
-        fakeTemplate = 'location.street';
-    }
-    else if (columnName === 'country') {
-        fakeTemplate = 'location.country';
-    }
-    else if (columnName === 'country_code') {
-        fakeTemplate = 'location.countryCode';
-    }
-    else if (columnName === 'color') {
-        fakeTemplate = 'color.human';
-    }
-    else if (columnName === 'account') {
-        fakeTemplate = 'finance.account';
-    }
-    else if (columnName === 'account_name') {
-        fakeTemplate = 'finance.accountName';
-    }
-    else if (columnName === 'currency_code') {
-        fakeTemplate = 'finance.currencyCode';
-    }
-    else if (columnName === 'currency_name') {
-        fakeTemplate = 'finance.currencyName';
-    }
-    else if (columnName === 'currency_symbol') {
-        fakeTemplate = 'finance.currencySymbol';
-    }
-    else if (columnName === 'iban') {
-        fakeTemplate = 'finance.iban';
-    }
-    else if (columnName === 'bic') {
-        fakeTemplate = 'finance.bic';
-    }
-    else if (columnName === 'email') {
-        fakeTemplate = 'internet.email';
-    }
-    else if (columnName === 'url') {
-        fakeTemplate = 'internet.url';
-    }
-    else {
-        fakeTemplate = 'word.words';
-    }
-    return `{{${fakeTemplate}}}`;
-};
-/**
- * @param {*} field
- * @param {import('@faker-js/faker').Faker} faker
- * @param {*} changelogDate
- * @param {string} type csv, cypress, json-serializable, ts
- * @returns fake value
- */
-function generateFakeDataForField(field, faker, changelogDate, type = 'csv') {
-    let data;
-    if (field.fakerTemplate) {
-        data = faker.faker(field.fakerTemplate);
-    }
-    else if (field.fieldValidate && field.fieldValidateRules.includes('pattern')) {
-        const re = field.createRandexp();
-        if (!re) {
-            return undefined;
-        }
-        const generated = re.gen();
-        if (type === 'csv' || type === 'cypress') {
-            data = generated.replace(/"/g, '');
-        }
-        else {
-            data = generated;
-        }
-        if (data.length === 0) {
-            this.log.warn(`Generated value for pattern ${field.fieldValidateRulesPattern} is not valid.`);
-            data = undefined;
-        }
-    }
-    else if (field.fieldIsEnum) {
-        if (field.fieldValues.length !== 0) {
-            const enumValues = field.enumValues;
-            data = enumValues[faker.number.int(enumValues.length - 1)].name;
-        }
-        else {
-            this.log.warn(`Enum ${field.fieldType} is not valid`);
-            data = undefined;
-        }
-    }
-    else if (field.fieldType === DURATION && type === 'cypress') {
-        data = `PT${faker.number.int({ min: 1, max: 59 })}M`;
-        // eslint-disable-next-line no-template-curly-in-string
-    }
-    else if ([FLOAT, '${floatType}', DOUBLE, BIG_DECIMAL].includes(field.fieldType)) {
-        data = faker.number.float({
-            max: field.fieldValidateRulesMax ? parseInt(field.fieldValidateRulesMax, 10) : 32767,
-            min: field.fieldValidateRulesMin ? parseInt(field.fieldValidateRulesMin, 10) : 0,
-            precision: 0.01,
-        });
-    }
-    else if ([INTEGER, LONG, DURATION].includes(field.fieldType)) {
-        data = faker.number.int({
-            max: field.fieldValidateRulesMax ? parseInt(field.fieldValidateRulesMax, 10) : 32767,
-            min: field.fieldValidateRulesMin ? parseInt(field.fieldValidateRulesMin, 10) : 0,
-        });
-    }
-    else if ([INSTANT, ZONED_DATE_TIME, LOCAL_DATE].includes(field.fieldType)) {
-        // Iso: YYYY-MM-DDTHH:mm:ss.sssZ
-        const date = faker.date.recent({ days: 1, refDate: changelogDate });
-        const isoDate = date.toISOString();
-        if (field.fieldType === LOCAL_DATE) {
-            data = isoDate.split('T')[0];
-        }
-        else if (type === 'json-serializable') {
-            data = date;
-        }
-        else {
-            // Write the date without milliseconds so Java can parse it
-            // See https://stackoverflow.com/a/34053802/150868
-            // YYYY-MM-DDTHH:mm:ss
-            data = isoDate.split('.')[0];
-            if (type === 'cypress' || type === 'ts') {
-                // YYYY-MM-DDTHH:mm
-                data = data.substr(0, data.length - 3);
-            }
-        }
-    }
-    else if (field.fieldType === BYTES && field.fieldTypeBlobContent !== TEXT) {
-        data = '../fake-data/blob/hipster.png';
-    }
-    else if (field.fieldType === BYTES && field.fieldTypeBlobContent === TEXT) {
-        data = '../fake-data/blob/hipster.txt';
-    }
-    else if (field.fieldType === STRING) {
-        data = field.id ? faker.string.uuid() : faker.helpers.fake(fakeStringTemplateForFieldName(field.columnName));
-    }
-    else if (field.fieldType === UUID) {
-        data = faker.string.uuid();
-    }
-    else if (field.fieldType === BOOLEAN) {
-        data = faker.datatype.boolean();
-    }
-    else {
-        this.log.warn(`Fake data for field ${field.fieldType} is not supported`);
-    }
-    if (field.fieldType === BYTES && type === 'json-serializable') {
-        data = Buffer.from(data).toString('base64');
-    }
-    // Validation rules
-    if (data !== undefined && field.fieldValidate === true) {
-        // manage String max length
-        if (field.fieldValidateRules.includes(MAXLENGTH)) {
-            const maxlength = field.fieldValidateRulesMaxlength;
-            data = data.substring(0, maxlength);
-        }
-        // manage String min length
-        if (field.fieldValidateRules.includes(MINLENGTH)) {
-            const minlength = field.fieldValidateRulesMinlength;
-            data = data.length > minlength ? data : data + 'X'.repeat(minlength - data.length);
-        }
-        // test if generated data is still compatible with the regexp as we potentially modify it with min/maxLength
-        if (field.fieldValidateRules.includes(PATTERN) && !new RegExp(`^${field.fieldValidateRulesPattern}$`).test(data)) {
-            data = undefined;
-        }
-    }
-    if (data !== undefined) {
-        // eslint-disable-next-line no-template-curly-in-string
-        if (type === 'ts' && ![BOOLEAN, INTEGER, LONG, FLOAT, '${floatType}', DOUBLE, BIG_DECIMAL].includes(field.fieldType)) {
-            data = `'${typeof data === 'string' ? data.replace(/'/g, "\\'") : data}'`;
-        }
-        else if (type === 'csv' && field.fieldValidate && field.fieldValidateRules.includes(PATTERN)) {
-            data = `"${typeof data === 'string' ? data.replace(/"/g, '\\"') : data}"`;
-        }
-    }
-    return data;
-}
-function _derivedProperties(field) {
-    const fieldType = field.fieldType;
-    const fieldTypeBlobContent = field.fieldTypeBlobContent;
-    const validationRules = field.fieldValidate ? field.fieldValidateRules : [];
-    _.defaults(field, {
-        blobContentTypeText: fieldTypeBlobContent === TEXT,
-        blobContentTypeImage: fieldTypeBlobContent === IMAGE,
-        blobContentTypeAny: fieldTypeBlobContent === ANY,
-        fieldTypeBoolean: fieldType === BOOLEAN,
-        fieldTypeBigDecimal: fieldType === BIG_DECIMAL,
-        fieldTypeDouble: fieldType === DOUBLE,
-        fieldTypeDuration: fieldType === DURATION,
-        fieldTypeFloat: fieldType === FLOAT,
-        fieldTypeInstant: fieldType === INSTANT,
-        fieldTypeInteger: fieldType === INTEGER,
-        fieldTypeLocalDate: fieldType === LOCAL_DATE,
-        fieldTypeLong: fieldType === LONG,
-        fieldTypeString: fieldType === STRING,
-        fieldTypeUUID: fieldType === UUID,
-        fieldTypeZonedDateTime: fieldType === ZONED_DATE_TIME,
-        fieldTypeImageBlob: fieldType === IMAGE_BLOB,
-        fieldTypeAnyBlob: fieldType === ANY_BLOB,
-        fieldTypeTextBlob: fieldType === TEXT_BLOB,
-        fieldTypeBlob: fieldType === BLOB,
-        fieldTypeBytes: fieldType === BYTES,
-        fieldTypeByteBuffer: fieldType === BYTE_BUFFER,
-        fieldTypeNumeric: fieldType === INTEGER || fieldType === LONG || fieldType === FLOAT || fieldType === DOUBLE || fieldType === BIG_DECIMAL,
-        fieldTypeBinary: fieldType === BYTES || fieldType === BYTE_BUFFER,
-        fieldTypeTimed: fieldType === ZONED_DATE_TIME || fieldType === INSTANT,
-        fieldTypeCharSequence: fieldType === STRING || fieldType === UUID,
-        fieldTypeTemporal: fieldType === ZONED_DATE_TIME || fieldType === INSTANT || fieldType === LOCAL_DATE,
-        fieldValidationRequired: validationRules.includes(REQUIRED),
-        fieldValidationMin: validationRules.includes(MIN),
-        fieldValidationMinLength: validationRules.includes(MINLENGTH),
-        fieldValidationMax: validationRules.includes(MAX),
-        fieldValidationMaxLength: validationRules.includes(MAXLENGTH),
-        fieldValidationPattern: validationRules.includes(PATTERN),
-        fieldValidationUnique: validationRules.includes(UNIQUE),
-        fieldValidationMinBytes: validationRules.includes(MINBYTES),
-        fieldValidationMaxBytes: validationRules.includes(MAXBYTES),
-    });
-}
-export default function prepareField(entityWithConfig, field, generator) {
-    prepareCommonFieldForTemplates(entityWithConfig, field, generator);
-    if (entityWithConfig.prodDatabaseType || entityWithConfig.databaseType) {
-        prepareServerFieldForTemplates(entityWithConfig, field, generator);
-    }
-    prepareClientFieldForTemplates(entityWithConfig, field, generator);
-    return field;
-}
-function prepareCommonFieldForTemplates(entityWithConfig, field, generator) {
-    mutateData(field, {
-        path: [field.fieldName],
-        propertyName: field.fieldName,
-        propertyNameCapitalized: ({ propertyName, propertyNameCapitalized }) => propertyNameCapitalized ?? _.upperFirst(propertyName),
-        fieldNameCapitalized: ({ fieldName, fieldNameCapitalized }) => fieldNameCapitalized ?? _.upperFirst(fieldName),
-        fieldNameUnderscored: ({ fieldName, fieldNameUnderscored }) => fieldNameUnderscored ?? _.snakeCase(fieldName),
-        fieldNameHumanized: ({ fieldName, fieldNameHumanized }) => fieldNameHumanized ?? _.startCase(fieldName),
-        fieldTranslationKey: ({ fieldName, fieldTranslationKey }) => fieldTranslationKey ?? `${entityWithConfig.i18nKeyPrefix}.${fieldName}`,
-        tsType: ({ fieldType, tsType }) => tsType ?? getTypescriptType(fieldType),
-    });
-    _.defaults(field, {
-        entity: entityWithConfig,
-    });
-    const fieldType = field.fieldType;
-    field.fieldIsEnum = !field.id && fieldIsEnum(fieldType);
-    if (field.fieldIsEnum) {
-        field.enumFileName = _.kebabCase(field.fieldType);
-        field.enumValues = getEnumValuesWithCustomValues(field.fieldValues);
-    }
-    field.fieldWithContentType = (fieldType === BYTES || fieldType === BYTE_BUFFER) && field.fieldTypeBlobContent !== TEXT;
-    if (field.fieldWithContentType) {
-        field.contentTypeFieldName = `${field.fieldName}ContentType`;
-    }
-    field.fieldValidate = Array.isArray(field.fieldValidateRules) && field.fieldValidateRules.length >= 1;
-    _.defaults(field, {
-        nullable: !(field.fieldValidate === true && field.fieldValidateRules.includes(REQUIRED)),
-    });
-    field.unique = field.fieldValidate === true && field.fieldValidateRules.includes(UNIQUE);
-    if (field.fieldValidate === true && field.fieldValidateRules.includes(MAXLENGTH)) {
-        field.maxlength = field.fieldValidateRulesMaxlength || 255;
-    }
-    const faker = entityWithConfig.faker;
-    field.createRandexp = () => {
-        // check if regex is valid. If not, issue warning and we skip fake data generation.
-        try {
-            // eslint-disable-next-line no-new
-            new RegExp(field.fieldValidateRulesPattern);
-        }
-        catch (e) {
-            generator.log.warn(`${field.fieldName} pattern is not valid: ${field.fieldValidateRulesPattern}. Skipping generating fake data. `);
-            return undefined;
-        }
-        const re = faker.createRandexp(field.fieldValidateRulesPattern);
-        if (!re) {
-            generator.log.warn(`Error creating generator for pattern ${field.fieldValidateRulesPattern}`);
-        }
-        return re;
-    };
-    field.uniqueValue = [];
-    field.generateFakeData = (type = 'csv') => {
-        let data = generateFakeDataForField.call(generator, field, faker, entityWithConfig.changelogDateForRecent, type);
-        // manage uniqueness
-        if ((field.fieldValidate === true && field.fieldValidateRules.includes(UNIQUE)) || field.id) {
-            let i = 0;
-            while (field.uniqueValue.indexOf(data) !== -1) {
-                if (i++ === 5) {
-                    data = undefined;
-                    break;
-                }
-                data = generateFakeDataForField.call(generator, field, faker, entityWithConfig.changelogDateForRecent, type);
-            }
-            if (data === undefined) {
-                generator.log.warn(`Error generating a unique value field ${field.fieldName} and type ${field.fieldType}`);
-            }
-            else {
-                field.uniqueValue.push(data);
-            }
-        }
-        if (data === undefined) {
-            generator.log.warn(`Error generating fake data for field ${entityWithConfig.name}.${field.fieldName}`);
-        }
-        return data;
-    };
-    field.relationshipsPath = [];
-    field.reference = fieldToReference(entityWithConfig, field);
-    _derivedProperties(field);
-    return field;
-}
-/**
- * From an enum's values (with or without custom values), returns the enum's values without custom values.
- * @param {String} [enumValues] - an enum's values.
- * @return {Array<String>} the formatted enum's values.
- */
-export function getEnumValuesWithCustomValues(enumValues) {
-    if (!enumValues || enumValues === '') {
-        throw new Error('Enumeration values must be passed to get the formatted values.');
-    }
-    return enumValues.split(',').map(enumValue => {
-        if (!enumValue.includes('(')) {
-            return { name: enumValue.trim(), value: enumValue.trim() };
-        }
-        const matched = /\s*(.+?)\s*\((.+?)\)/.exec(enumValue);
-        return {
-            name: matched[1],
-            value: matched[2],
-        };
-    });
-}
-export function fieldToReference(entity, field, pathPrefix = []) {
-    return {
-        id: field.id,
-        entity,
-        field,
-        multiple: false,
-        owned: true,
-        doc: field.documentation,
-        get propertyJavadoc() {
-            return field.fieldJavadoc;
-        },
-        get propertyApiDescription() {
-            return field.fieldApiDescription;
-        },
-        label: field.fieldNameHumanized,
-        name: field.fieldName,
-        type: field.fieldType,
-        nameCapitalized: field.fieldNameCapitalized,
-        path: [...pathPrefix, field.fieldName],
-    };
-}

package/dist/generators/base-application/support/prepare-relationship.mjs

@@ -1,237 +0,0 @@
-/**
- * Copyright 2013-2023 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 * as _ from 'lodash-es';
-import pluralize from 'pluralize';
-import { databaseTypes, entityOptions, reservedKeywords, validations, checkAndReturnRelationshipOnValue, } from '../../../jdl/jhipster/index.mjs';
-import { upperFirstCamelCase } from '../../base/support/string.mjs';
-import { getJoinTableName, hibernateSnakeCase } from '../../server/support/index.mjs';
-import { stringifyApplicationData } from './debug.mjs';
-import { mutateData } from '../../base/support/config.mjs';
-const { isReservedTableName } = reservedKeywords;
-const { NEO4J, NO: DATABASE_NO } = databaseTypes;
-const { MapperTypes } = entityOptions;
-const { Validations: { REQUIRED }, } = validations;
-const { MAPSTRUCT } = MapperTypes;
-function _defineOnUpdateAndOnDelete(relationship, generator) {
-    relationship.onDelete = checkAndReturnRelationshipOnValue(relationship.options?.onDelete, generator);
-    relationship.onUpdate = checkAndReturnRelationshipOnValue(relationship.options?.onUpdate, generator);
-}
-export default function prepareRelationship(entityWithConfig, relationship, generator, ignoreMissingRequiredRelationship) {
-    const entityName = entityWithConfig.name;
-    const otherEntityName = relationship.otherEntityName;
-    const jhiTablePrefix = entityWithConfig.jhiTablePrefix || hibernateSnakeCase(entityWithConfig.jhiPrefix);
-    if (!relationship.otherEntity) {
-        throw new Error(`Error at entity ${entityName}: could not find the entity of the relationship ${stringifyApplicationData(relationship)}`);
-    }
-    const otherEntityData = relationship.otherEntity;
-    if (!relationship.otherEntityField && otherEntityData.primaryKey) {
-        relationship.otherEntityField = otherEntityData.primaryKey.name;
-    }
-    Object.assign(relationship, {
-        relationshipLeftSide: relationship.relationshipSide === 'left',
-        relationshipRightSide: relationship.relationshipSide === 'right',
-        collection: relationship.relationshipType === 'one-to-many' || relationship.relationshipType === 'many-to-many',
-        relationshipOneToOne: relationship.relationshipType === 'one-to-one',
-        relationshipOneToMany: relationship.relationshipType === 'one-to-many',
-        relationshipManyToOne: relationship.relationshipType === 'many-to-one',
-        relationshipManyToMany: relationship.relationshipType === 'many-to-many',
-        otherEntityUser: relationship.otherEntityName === 'user',
-    });
-    mutateData(relationship, {
-        // let ownerSide true when type is 'many-to-one' for convenience.
-        // means that this side should control the reference.
-        ownerSide: ({ ownerSide, relationshipLeftSide, relationshipManyToOne, relationshipOneToMany }) => ownerSide ?? (relationshipManyToOne || (relationshipLeftSide && !relationshipOneToMany)),
-        persistableRelationship: ({ persistableRelationship, ownerSide }) => persistableRelationship ?? ownerSide,
-        relationshipUpdateBackReference: ({ relationshipUpdateBackReference, ownerSide, relationshipRightSide }) => relationshipUpdateBackReference ?? (entityWithConfig.databaseType === 'neo4j' ? relationshipRightSide : !ownerSide),
-    });
-    relationship.otherSideReferenceExists = false;
-    relationship.otherEntityIsEmbedded = otherEntityData.embedded;
-    // Look for fields at the other other side of the relationship
-    if (otherEntityData.relationships) {
-        const otherRelationship = relationship.otherRelationship;
-        if (otherRelationship) {
-            relationship.otherSideReferenceExists = true;
-            _.defaults(relationship, {
-                otherRelationship,
-                otherEntityRelationshipName: otherRelationship.relationshipName,
-                otherEntityRelationshipNamePlural: otherRelationship.relationshipNamePlural,
-                otherEntityRelationshipNameCapitalized: otherRelationship.relationshipNameCapitalized,
-                otherEntityRelationshipNameCapitalizedPlural: relationship.relationshipNameCapitalizedPlural,
-            });
-        }
-        else if (!ignoreMissingRequiredRelationship &&
-            entityWithConfig.databaseType !== NEO4J &&
-            entityWithConfig.databaseType !== DATABASE_NO &&
-            (relationship.relationshipType === 'one-to-many' || relationship.ownerSide === false)) {
-            if (otherEntityData.builtInUser) {
-                throw new Error(`Error at entity ${entityName}: relationships with built-in User cannot have back reference`);
-            }
-            throw new Error(`Error at entity ${entityName}: could not find the other side of the relationship ${stringifyApplicationData(relationship)}`);
-        }
-        else {
-            generator.debug(`Entity ${entityName}: Could not find the other side of the relationship ${stringifyApplicationData(relationship)}`);
-        }
-    }
-    relationship.relatedField = otherEntityData.fields.find(field => field.fieldName === relationship.otherEntityField);
-    if (!relationship.relatedField && otherEntityData.primaryKey && otherEntityData.primaryKey.derived) {
-        Object.defineProperty(relationship, 'relatedField', {
-            get() {
-                return otherEntityData.primaryKey.derivedFields.find(field => field.fieldName === relationship.otherEntityField);
-            },
-        });
-    }
-    if (relationship.relatedField) {
-        relationship.otherEntityFieldCapitalized = relationship.relatedField.fieldNameCapitalized;
-        relationship.relatedField.relatedByOtherEntity = true;
-    }
-    else {
-        relationship.otherEntityFieldCapitalized = _.upperFirst(relationship.otherEntityField);
-    }
-    if (relationship.otherEntityRelationshipName !== undefined) {
-        _.defaults(relationship, {
-            otherEntityRelationshipNamePlural: pluralize(relationship.otherEntityRelationshipName),
-            otherEntityRelationshipNameCapitalized: _.upperFirst(relationship.otherEntityRelationshipName),
-        });
-        _.defaults(relationship, {
-            otherEntityRelationshipNameCapitalizedPlural: pluralize(relationship.otherEntityRelationshipNameCapitalized),
-        });
-    }
-    const relationshipName = relationship.relationshipName;
-    _.defaults(relationship, {
-        relationshipNamePlural: pluralize(relationshipName),
-        relationshipFieldName: _.lowerFirst(relationshipName),
-        relationshipNameCapitalized: _.upperFirst(relationshipName),
-        relationshipNameHumanized: _.startCase(relationshipName),
-        columnName: hibernateSnakeCase(relationshipName),
-        columnNamePrefix: relationship.id && relationship.relationshipType === 'one-to-one' ? '' : `${hibernateSnakeCase(relationshipName)}_`,
-        otherEntityNamePlural: pluralize(otherEntityName),
-        otherEntityNameCapitalized: _.upperFirst(otherEntityName),
-        otherEntityTableName: otherEntityData.entityTableName ||
-            hibernateSnakeCase(otherEntityData.builtInUser ? `${jhiTablePrefix}_${otherEntityName}` : otherEntityName),
-    });
-    _.defaults(relationship, {
-        relationshipFieldNamePlural: pluralize(relationship.relationshipFieldName),
-        relationshipNameCapitalizedPlural: relationship.relationshipName.length > 1
-            ? pluralize(relationship.relationshipNameCapitalized)
-            : _.upperFirst(pluralize(relationship.relationshipName)),
-        otherEntityNameCapitalizedPlural: pluralize(relationship.otherEntityNameCapitalized),
-    });
-    mutateData(relationship, {
-        propertyName: relationship.collection ? relationship.relationshipFieldNamePlural : relationship.relationshipFieldName,
-        propertyNameCapitalized: ({ propertyName, propertyNameCapitalized }) => propertyNameCapitalized ?? _.upperFirst(propertyName),
-    });
-    if (entityWithConfig.dto === MAPSTRUCT) {
-        if (otherEntityData.dto !== MAPSTRUCT && !otherEntityData.builtInUser) {
-            generator.log.warn(`Entity ${entityName}: this entity has the DTO option, and it has a relationship with entity "${otherEntityName}" that doesn't have the DTO option. This will result in an error.`);
-        }
-    }
-    if (entityWithConfig.prodDatabaseType) {
-        if (isReservedTableName(relationship.otherEntityTableName, entityWithConfig.prodDatabaseType) && jhiTablePrefix) {
-            const otherEntityTableName = relationship.otherEntityTableName;
-            relationship.otherEntityTableName = `${jhiTablePrefix}_${otherEntityTableName}`;
-        }
-    }
-    if (relationship.otherEntityAngularName === undefined) {
-        if (otherEntityData.builtInUser) {
-            relationship.otherEntityAngularName = 'User';
-        }
-        else {
-            const otherEntityAngularSuffix = otherEntityData ? otherEntityData.angularJSSuffix || '' : '';
-            relationship.otherEntityAngularName = _.upperFirst(relationship.otherEntityName) + upperFirstCamelCase(otherEntityAngularSuffix);
-        }
-    }
-    _.defaults(relationship, {
-        otherEntityStateName: _.kebabCase(relationship.otherEntityAngularName),
-        jpaMetamodelFiltering: otherEntityData.jpaMetamodelFiltering,
-        unique: relationship.id || (relationship.ownerSide && relationship.relationshipType === 'one-to-one'),
-    });
-    if (!otherEntityData.builtInUser) {
-        _.defaults(relationship, {
-            otherEntityFileName: _.kebabCase(relationship.otherEntityAngularName),
-            otherEntityFolderName: _.kebabCase(relationship.otherEntityAngularName),
-        });
-        const otherEntityClientRootFolder = otherEntityData.clientRootFolder || otherEntityData.microserviceName || '';
-        if (entityWithConfig.skipUiGrouping || !otherEntityClientRootFolder) {
-            relationship.otherEntityClientRootFolder = '';
-        }
-        else {
-            relationship.otherEntityClientRootFolder = `${otherEntityClientRootFolder}/`;
-        }
-        if (otherEntityClientRootFolder) {
-            if (entityWithConfig.clientRootFolder === otherEntityClientRootFolder) {
-                relationship.otherEntityModulePath = relationship.otherEntityFolderName;
-            }
-            else {
-                relationship.otherEntityModulePath = `${entityWithConfig.entityParentPathAddition ? `${entityWithConfig.entityParentPathAddition}/` : ''}${otherEntityClientRootFolder}/${relationship.otherEntityFolderName}`;
-            }
-            relationship.otherEntityModelName = `${otherEntityClientRootFolder}/${relationship.otherEntityFileName}`;
-            relationship.otherEntityPath = `${otherEntityClientRootFolder}/${relationship.otherEntityFolderName}`;
-        }
-        else {
-            relationship.otherEntityModulePath = `${entityWithConfig.entityParentPathAddition ? `${entityWithConfig.entityParentPathAddition}/` : ''}${relationship.otherEntityFolderName}`;
-            relationship.otherEntityModelName = relationship.otherEntityFileName;
-            relationship.otherEntityPath = relationship.otherEntityFolderName;
-        }
-    }
-    if (relationship.relationshipValidateRules && relationship.relationshipValidateRules.includes(REQUIRED)) {
-        if (entityName.toLowerCase() === relationship.otherEntityName.toLowerCase()) {
-            generator.log.warn(`Error at entity ${entityName}: required relationships to the same entity are not supported.`);
-        }
-        else {
-            relationship.relationshipValidate = relationship.relationshipRequired = true;
-        }
-    }
-    relationship.nullable = !(relationship.relationshipValidate === true && relationship.relationshipRequired);
-    relationship.shouldWriteJoinTable = relationship.relationshipType === 'many-to-many' && relationship.ownerSide;
-    if (relationship.shouldWriteJoinTable) {
-        relationship.joinTable = {
-            name: getJoinTableName(entityWithConfig.entityTableName, relationship.relationshipName, {
-                prodDatabaseType: entityWithConfig.prodDatabaseType,
-            }).value,
-        };
-    }
-    relationship.reference = relationshipToReference(entityWithConfig, relationship);
-    _defineOnUpdateAndOnDelete(relationship, generator);
-    return relationship;
-}
-function relationshipToReference(entity, relationship, pathPrefix = []) {
-    const collection = relationship.collection;
-    const name = collection ? relationship.relationshipNamePlural : relationship.relationshipName;
-    const reference = {
-        id: relationship.id,
-        entity,
-        relationship,
-        owned: relationship.ownerSide,
-        collection,
-        doc: relationship.documentation,
-        get propertyJavadoc() {
-            return relationship.relationshipJavadoc;
-        },
-        get propertyApiDescription() {
-            return relationship.relationshipApiDescription;
-        },
-        name,
-        nameCapitalized: collection ? relationship.relationshipNameCapitalizedPlural : relationship.relationshipNameCapitalized,
-        get type() {
-            return relationship.otherEntity.primaryKey ? relationship.otherEntity.primaryKey.type : undefined;
-        },
-        path: [...pathPrefix, name],
-    };
-    return reference;
-}