generator-jhipster 8.7.0 → 8.7.1

package/dist/lib/jdl/converters/parsed-jdl-to-jdl-object/parsed-jdl-to-jdl-object-converter.js

@@ -0,0 +1,179 @@
+/**
+ * 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 { lowerFirst } from 'lodash-es';
+import JDLObject from '../../core/models/jdl-object.js';
+import JDLBinaryOption from '../../core/models/jdl-binary-option.js';
+import { binaryOptions } from '../../core/built-in-options/index.js';
+import { applicationTypes } from '../../../jhipster/index.js';
+import { convertApplications } from './application-converter.js';
+import { convertEntities } from './entity-converter.js';
+import { convertEnums } from './enum-converter.js';
+import { convertField } from './field-converter.js';
+import { convertValidations } from './validation-converter.js';
+import { convertOptions } from './option-converter.js';
+import { convertRelationships } from './relationship-converter.js';
+import { convertDeployments } from './deployment-converter.js';
+let parsedContent;
+let configuration;
+let jdlObject;
+let entityNames;
+let applicationsPerEntityName;
+/**
+ * Converts the intermediate parsedContent to a JDLObject from a configuration object.
+ * @param {Object} configurationObject - The configuration object.
+ * @param {Object} configurationObject.document - Deprecated set parsedContent instead, the parsed JDL content
+ * @param {Object} configurationObject.parsedContent - The parsed JDL content
+ * @param {String} configurationObject.applicationType - The application's type
+ * @param {String} configurationObject.applicationName - The application's name
+ * @param {String} configurationObject.databaseType - The application's database type
+ * @return the built JDL object.
+ */
+export function parseFromConfigurationObject(configurationObject, runtime) {
+    parsedContent = configurationObject.parsedContent || configurationObject.document;
+    if (!parsedContent) {
+        throw new Error('The parsed JDL content must be passed.');
+    }
+    init(configurationObject);
+    fillApplications(runtime);
+    fillDeployments();
+    fillEnums();
+    fillClassesAndFields();
+    fillAssociations();
+    fillOptions();
+    return jdlObject;
+}
+function init(passedConfiguration) {
+    configuration = passedConfiguration;
+    jdlObject = new JDLObject();
+    entityNames = parsedContent.entities.map(entity => entity.name);
+    applicationsPerEntityName = new Map();
+}
+function fillApplications(runtime) {
+    // TODO: Function which expects two arguments is called with three.
+    const jdlApplications = convertApplications(parsedContent.applications, runtime);
+    jdlApplications.forEach((jdlApplication) => {
+        jdlObject.addApplication(jdlApplication);
+        fillApplicationsPerEntityName(jdlApplication);
+    });
+}
+function fillApplicationsPerEntityName(application) {
+    application.forEachEntityName((entityName) => {
+        applicationsPerEntityName[entityName] = applicationsPerEntityName[entityName] || [];
+        applicationsPerEntityName[entityName].push(application);
+    });
+}
+function fillDeployments() {
+    const jdlDeployments = convertDeployments(parsedContent.deployments);
+    jdlDeployments.forEach(jdlDeployment => {
+        jdlObject.addDeployment(jdlDeployment);
+    });
+}
+function fillEnums() {
+    const jdlEnums = convertEnums(parsedContent.enums);
+    jdlEnums.forEach(jdlEnum => {
+        jdlObject.addEnum(jdlEnum);
+    });
+}
+function fillClassesAndFields() {
+    const jdlEntities = convertEntities(parsedContent.entities, getJDLFieldsFromParsedEntity);
+    jdlEntities.forEach(jdlEntity => {
+        jdlObject.addEntity(jdlEntity);
+    });
+}
+function getJDLFieldsFromParsedEntity(entity) {
+    const fields = [];
+    const arr = entity.body || [];
+    for (let i = 0; i < arr.length; i++) {
+        const field = arr[i];
+        const jdlField = convertField(field);
+        jdlField.validations = getValidations(field);
+        jdlField.options = convertAnnotationsToOptions(field.annotations || []);
+        fields.push(jdlField);
+    }
+    return fields;
+}
+function getValidations(field) {
+    return convertValidations(field.validations, getConstantValueFromConstantName).reduce((jdlValidations, jdlValidation) => {
+        jdlValidations[jdlValidation.name] = jdlValidation;
+        return jdlValidations;
+    }, {});
+}
+function getConstantValueFromConstantName(constantName) {
+    return parsedContent.constants[constantName];
+}
+function fillAssociations() {
+    const jdlRelationships = convertRelationships(parsedContent.relationships, convertAnnotationsToOptions);
+    jdlRelationships.forEach(jdlRelationship => {
+        // TODO: addRelationship only expects one argument.
+        jdlObject.addRelationship(jdlRelationship);
+    });
+}
+function convertAnnotationsToOptions(annotations) {
+    const result = {};
+    annotations.forEach(annotation => {
+        const annotationName = lowerFirst(annotation.optionName);
+        const value = annotation.optionValue ? annotation.optionValue : true;
+        if (annotationName in result) {
+            const previousValue = result[annotationName];
+            if (Array.isArray(previousValue)) {
+                if (!previousValue.includes(value)) {
+                    previousValue.push(value);
+                }
+            }
+            else if (value !== previousValue) {
+                result[annotationName] = [previousValue, value];
+            }
+        }
+        else {
+            result[annotationName] = value;
+        }
+    });
+    return result;
+}
+function fillOptions() {
+    if (configuration.applicationType === applicationTypes.MICROSERVICE && !parsedContent.options.microservice) {
+        globallyAddMicroserviceOption(configuration.applicationName);
+    }
+    fillUnaryAndBinaryOptions();
+}
+// TODO: move it to another file? it may not be the parser's responsibility to do it
+function globallyAddMicroserviceOption(applicationName) {
+    jdlObject.addOption(new JDLBinaryOption({
+        name: binaryOptions.Options.MICROSERVICE,
+        value: applicationName,
+        entityNames,
+    }));
+}
+function fillUnaryAndBinaryOptions() {
+    // TODO: move it to another file? it may not be the parser's responsibility to do it
+    if (configuration.applicationType === applicationTypes.MICROSERVICE) {
+        jdlObject.addOption(new JDLBinaryOption({
+            name: binaryOptions.Options.CLIENT_ROOT_FOLDER,
+            value: configuration.applicationName,
+            entityNames,
+        }));
+    }
+    const convertedOptions = convertOptions(parsedContent.options, parsedContent.useOptions);
+    convertedOptions.forEach(convertedOption => {
+        jdlObject.addOption(convertedOption);
+    });
+}
+export default {
+    parseFromConfigurationObject,
+};

package/dist/lib/jdl/converters/parsed-jdl-to-jdl-object/relationship-converter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 JDLRelationship from '../../core/models/jdl-relationship.js';
+import type { ParsedJDLAnnotation, ParsedJDLRelationship } from '../../core/types/parsed.js';
+declare const _default: {
+    convertRelationships: typeof convertRelationships;
+};
+export default _default;
+/**
+ * Converts parsed relationships to JDLRelationship objects.
+ * @param {Array<Object>} parsedRelationships - the parsed relationships.
+ * @param {Function} annotationToOptionConverter - the function that can convert annotations to options.
+ * @return the converted JDL relationships.
+ */
+export declare function convertRelationships(parsedRelationships: ParsedJDLRelationship[], annotationToOptionConverter: (annotations: ParsedJDLAnnotation[]) => Record<string, boolean | string | number | string[] | boolean[] | number[]>): JDLRelationship[];

package/dist/lib/jdl/converters/parsed-jdl-to-jdl-object/relationship-converter.js

@@ -0,0 +1,57 @@
+/**
+ * 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 JDLRelationship from '../../core/models/jdl-relationship.js';
+import { lowerFirst } from '../../core/utils/string-utils.js';
+import { formatComment } from '../../core/utils/format-utils.js';
+import { asJdlRelationshipType } from '../../core/basic-types/relationship-types.js';
+export default { convertRelationships };
+/**
+ * Converts parsed relationships to JDLRelationship objects.
+ * @param {Array<Object>} parsedRelationships - the parsed relationships.
+ * @param {Function} annotationToOptionConverter - the function that can convert annotations to options.
+ * @return the converted JDL relationships.
+ */
+export function convertRelationships(parsedRelationships, annotationToOptionConverter) {
+    if (!parsedRelationships) {
+        throw new Error('Relationships have to be passed so as to be converted.');
+    }
+    return parsedRelationships.map(parsedRelationship => {
+        const relationshipConfiguration = {
+            from: parsedRelationship.from.name,
+            to: parsedRelationship.to.name,
+            type: asJdlRelationshipType(parsedRelationship.cardinality),
+            injectedFieldInFrom: parsedRelationship.from.injectedField,
+            injectedFieldInTo: parsedRelationship.to.injectedField,
+            isInjectedFieldInFromRequired: parsedRelationship.from.required,
+            isInjectedFieldInToRequired: parsedRelationship.to.required,
+            commentInFrom: formatComment(parsedRelationship.from.documentation),
+            commentInTo: formatComment(parsedRelationship.to.documentation),
+            options: {
+                global: annotationToOptionConverter.call(undefined, parsedRelationship.options.global),
+                source: annotationToOptionConverter.call(undefined, parsedRelationship.options.source),
+                destination: annotationToOptionConverter.call(undefined, parsedRelationship.options.destination),
+            },
+        };
+        if (!relationshipConfiguration.injectedFieldInFrom && !relationshipConfiguration.injectedFieldInTo) {
+            relationshipConfiguration.injectedFieldInFrom = lowerFirst(relationshipConfiguration.to);
+            relationshipConfiguration.injectedFieldInTo = lowerFirst(relationshipConfiguration.from);
+        }
+        return new JDLRelationship(relationshipConfiguration);
+    });
+}

package/dist/lib/jdl/converters/parsed-jdl-to-jdl-object/validation-converter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 JDLValidation from '../../core/models/jdl-validation.js';
+import type { ParsedJDLValidation } from '../../core/types/parsed.js';
+declare const _default: {
+    convertValidations: typeof convertValidations;
+};
+export default _default;
+/**
+ * Converts a parsed JDL content corresponding to validations to an array of JDLValidation objects.
+ * @param {Array} validations - parsed JDL validations.
+ * @param constantValueGetter - the function to get a constant's value.
+ * @return the converted JDLValidations.
+ */
+export declare function convertValidations(validations: ParsedJDLValidation[], constantValueGetter?: (constant: string) => string | number | boolean | RegExp): JDLValidation[];

package/dist/lib/jdl/converters/parsed-jdl-to-jdl-object/validation-converter.js

@@ -0,0 +1,70 @@
+/**
+ * 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 JDLValidation from '../../core/models/jdl-validation.js';
+import { validations } from '../../core/built-in-options/index.js';
+const { Validations: { PATTERN }, } = validations;
+export default { convertValidations };
+/**
+ * Converts a parsed JDL content corresponding to validations to an array of JDLValidation objects.
+ * @param {Array} validations - parsed JDL validations.
+ * @param constantValueGetter - the function to get a constant's value.
+ * @return the converted JDLValidations.
+ */
+export function convertValidations(validations, constantValueGetter) {
+    if (!validations) {
+        throw new Error('Validations have to be passed so as to be converted.');
+    }
+    return validations.reduce((jdlValidations, parsedValidation) => {
+        if (parsedValidation) {
+            jdlValidations = [...jdlValidations, convertValidation(parsedValidation, constantValueGetter)];
+        }
+        return jdlValidations;
+    }, []);
+}
+/**
+ * Converts a parsed JDL content corresponding to a validation to a JDLValidation object.
+ * @param {Object} validation - a parsed JDL validation.
+ * @param {Function} constantValueGetter - the function to get a constant's value.
+ * @return the converted JDLValidation.
+ */
+function convertValidation(validation, constantValueGetter) {
+    let { value } = validation;
+    if (validation.constant) {
+        value = constantValueGetter.call(undefined, value);
+    }
+    if (validation.key === PATTERN) {
+        value = formatThePatternValidationValue(value);
+    }
+    return new JDLValidation({
+        name: validation.key,
+        value,
+    });
+}
+function formatThePatternValidationValue(value) {
+    if (!value.includes("'")) {
+        return value;
+    }
+    const chunks = value.split("'").map(chunk => {
+        if (!chunk.endsWith('\\')) {
+            return `${chunk}\\`;
+        }
+        return chunk;
+    });
+    return chunks.join("\\'");
+}

package/dist/lib/jdl/converters/validators/binary-option-validator.js

@@ -0,0 +1,34 @@
+/**
+ * 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 BinaryOptions from '../../core/built-in-options/binary-options.js';
+import OptionValidator from './option-validator.js';
+export default class BinaryOptionValidator extends OptionValidator {
+    constructor() {
+        super('binary', 'value');
+    }
+    validate(jdlOption) {
+        super.validate(jdlOption);
+        checkForInvalidValue(jdlOption);
+    }
+}
+function checkForInvalidValue(jdlOption) {
+    if (!!jdlOption.value && !BinaryOptions.exists(jdlOption.name, jdlOption.value)) {
+        throw new Error(`The '${jdlOption.name}' option is not valid for value '${jdlOption.value}'.`);
+    }
+}

package/dist/lib/jdl/converters/validators/deployment-validator.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 type JDLDeployment from '../../core/models/jdl-deployment.js';
+import Validator from './validator.js';
+export default class DeploymentValidator extends Validator {
+    constructor();
+    validate(jdlDeployment: JDLDeployment, options?: {}): void;
+}

package/dist/lib/jdl/converters/validators/deployment-validator.js

@@ -0,0 +1,56 @@
+/**
+ * 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 { applicationTypes, deploymentOptions } from '../../../jhipster/index.js';
+import Validator from './validator.js';
+const { Options } = deploymentOptions;
+const { MICROSERVICE } = applicationTypes;
+export default class DeploymentValidator extends Validator {
+    constructor() {
+        super('deployment', ['deploymentType', 'appsFolders', 'directoryPath']);
+    }
+    validate(jdlDeployment, options = {}) {
+        super.validate(jdlDeployment);
+        switch (jdlDeployment.deploymentType) {
+            case Options.deploymentType.dockerCompose:
+                validateDockerComposeRelatedDeployment(jdlDeployment, options);
+                break;
+            case Options.deploymentType.kubernetes:
+                validateKubernetesRelatedDeployment(jdlDeployment);
+                break;
+            default:
+                throw new Error(`The deployment type ${jdlDeployment.deploymentType} isn't supported.`);
+        }
+    }
+}
+function validateDockerComposeRelatedDeployment(jdlDeployment, options = {}) {
+    if (jdlDeployment.gatewayType !== Options.gatewayType.springCloudGateway && options.applicationType === MICROSERVICE) {
+        throw new Error('A gateway type must be provided when dealing with microservices and the deployment type is docker-compose.');
+    }
+}
+function validateKubernetesRelatedDeployment(jdlDeployment) {
+    if (!jdlDeployment.kubernetesServiceType) {
+        throw new Error('A kubernetes service type must be provided when dealing with kubernetes-related deployments.');
+    }
+    if (jdlDeployment.istio && !jdlDeployment.ingressDomain) {
+        throw new Error('An ingress domain must be provided when dealing with kubernetes-related deployments, with istio and when the service type is ingress.');
+    }
+    if (jdlDeployment.kubernetesServiceType === Options.kubernetesServiceType.ingress && !jdlDeployment.ingressType) {
+        throw new Error('An ingress type is required when dealing with kubernetes-related deployments and when the service type is ingress.');
+    }
+}

package/dist/lib/jdl/converters/validators/entity-validator.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 type { ValidatorOptions } from './validator.js';
+import Validator from './validator.js';
+export default class EntityValidator extends Validator {
+    constructor();
+    validate(jdlEntity: any, options?: ValidatorOptions): void;
+}

package/dist/lib/jdl/converters/validators/entity-validator.js

@@ -0,0 +1,37 @@
+/**
+ * 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 { reservedKeywords } from '../../../jhipster/index.js';
+import Validator from './validator.js';
+const { isReservedClassName } = reservedKeywords;
+export default class EntityValidator extends Validator {
+    constructor() {
+        super('entity', ['name']);
+    }
+    validate(jdlEntity, options = {}) {
+        super.validate(jdlEntity);
+        if (options.checkReservedKeywords) {
+            checkForReservedClassName(jdlEntity);
+        }
+    }
+}
+function checkForReservedClassName(jdlEntity) {
+    if (isReservedClassName(jdlEntity.name)) {
+        throw new Error(`The name '${jdlEntity.name}' is a reserved keyword and can not be used as an entity class name.`);
+    }
+}

package/dist/lib/jdl/converters/validators/enum-validator.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 type { ValidatorOptions } from './validator.js';
+import Validator from './validator.js';
+export default class EnumValidator extends Validator {
+    constructor();
+    validate(jdlEnum: any, options?: ValidatorOptions): void;
+}

package/dist/lib/jdl/converters/validators/enum-validator.js

@@ -0,0 +1,37 @@
+/**
+ * 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 { reservedKeywords } from '../../../jhipster/index.js';
+import Validator from './validator.js';
+const { isReservedClassName } = reservedKeywords;
+export default class EnumValidator extends Validator {
+    constructor() {
+        super('enum', ['name']);
+    }
+    validate(jdlEnum, options = {}) {
+        super.validate(jdlEnum);
+        if (options.checkReservedKeywords) {
+            checkForReservedClassName(jdlEnum);
+        }
+    }
+}
+function checkForReservedClassName(jdlEnum) {
+    if (isReservedClassName(jdlEnum.name)) {
+        throw new Error(`The enum name '${jdlEnum.name}' is reserved keyword and can not be used as enum class name.`);
+    }
+}

package/dist/lib/jdl/converters/validators/jdl-with-application-validator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 type JDLObject from '../../core/models/jdl-object.js';
+/**
+ * Constructor taking the jdl object to check against application settings.
+ * @param {JDLObject} jdlObject -  the jdl object to check.
+ * @param {Object} logger - the logger to use, default to the console.
+ * @param {Object} [options]
+ */
+export default function createValidator(jdlObject: JDLObject, logger?: any): {
+    checkForErrors: () => void;
+};