generator-jhipster 8.7.0 → 8.7.2

package/dist/lib/jdl/core/linters/relationship-linter.js

@@ -0,0 +1,65 @@
+/**
+ * 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 { relationshipTypes } from '../basic-types/index.js';
+import RelationshipIssue from './issues/relationship-issue.js';
+import { rulesNames } from './rules.js';
+let issues;
+export default {
+    checkRelationships,
+};
+/**
+ * Check relationships for lint issues.
+ * That is done by passing the list of relationship declarations from the CST (from the JDLReader output).
+ * @param {Array} relationshipDeclarations - the list of relationship declarations
+ * @return the found relationship issues.
+ */
+export function checkRelationships(relationshipDeclarations) {
+    if (!relationshipDeclarations || relationshipDeclarations.length === 0) {
+        return [];
+    }
+    issues = [];
+    checkForCollapsibleRelationships(relationshipDeclarations);
+    return issues;
+}
+function checkForCollapsibleRelationships(relationshipDeclarations) {
+    const sortedRelationships = {
+        [relationshipTypes.ONE_TO_ONE]: [],
+        [relationshipTypes.ONE_TO_MANY]: [],
+        [relationshipTypes.MANY_TO_ONE]: [],
+        [relationshipTypes.MANY_TO_MANY]: [],
+    };
+    relationshipDeclarations.forEach((relationshipDeclaration) => {
+        const type = relationshipDeclaration.children.relationshipType[0].children.RELATIONSHIP_TYPE[0].image;
+        const from = relationshipDeclaration.children.relationshipBody[0].children.from[0].children.NAME[0].image;
+        const to = relationshipDeclaration.children.relationshipBody[0].children.to[0].children.NAME[0].image;
+        sortedRelationships[type].push({ from, to });
+    });
+    Object.keys(sortedRelationships).forEach(type => {
+        if (sortedRelationships[type].length > 1) {
+            sortedRelationships[type].forEach(relationship => {
+                issues.push(new RelationshipIssue({
+                    ruleName: rulesNames.REL_INDIVIDUAL_DECL,
+                    from: relationship.from,
+                    to: relationship.to,
+                    type,
+                }));
+            });
+        }
+    });
+}

package/dist/lib/jdl/core/linters/rule.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 { RuleLevel } from './rule-levels.js';
+/**
+ * Represents a rule for the linters.
+ */
+export default class Rule {
+    name: any;
+    level: RuleLevel;
+    comment: any;
+    /**
+     * Creates a new rule from an arg object.
+     * @param args the argument object, keys:
+     *               - name: the rule's name
+     *               - level: the rule's level (INFO, WARNING, etc.), default: RuleLevels.INFO
+     *               - comment: a possible comment for the rule
+     */
+    constructor(args: {
+        name: any;
+        level: RuleLevel;
+        comment: any;
+    });
+    /**
+     * Compares this rule to another.
+     * @param otherRule the other rule.
+     * @returns 1 if this rule has a higher priority, 0 if they are equal, -1 otherwise.
+     */
+    compareTo(otherRule: Rule): number;
+}

package/dist/lib/jdl/core/linters/rule.js

@@ -0,0 +1,66 @@
+/**
+ * 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 { merge } from '../utils/object-utils.js';
+import { INFO } from './rule-levels.js';
+/**
+ * Represents a rule for the linters.
+ */
+export default class Rule {
+    name;
+    level;
+    comment;
+    /**
+     * Creates a new rule from an arg object.
+     * @param args the argument object, keys:
+     *               - name: the rule's name
+     *               - level: the rule's level (INFO, WARNING, etc.), default: RuleLevels.INFO
+     *               - comment: a possible comment for the rule
+     */
+    constructor(args) {
+        if (!args?.name) {
+            throw new Error('A rule must at least have a name.');
+        }
+        const merged = merge(defaults(), args);
+        this.name = merged.name;
+        this.level = merged.level;
+        this.comment = merged.comment;
+    }
+    /**
+     * Compares this rule to another.
+     * @param otherRule the other rule.
+     * @returns 1 if this rule has a higher priority, 0 if they are equal, -1 otherwise.
+     */
+    compareTo(otherRule) {
+        if (!otherRule) {
+            throw new Error('A rule has to be passed so as to be compared.');
+        }
+        if (this.level.priority === otherRule.level.priority) {
+            return 0;
+        }
+        if (this.level.priority > otherRule.level.priority) {
+            return 1;
+        }
+        return -1;
+    }
+}
+function defaults() {
+    return {
+        level: INFO,
+    };
+}

package/dist/lib/jdl/core/matchers/entity-matcher.js

@@ -0,0 +1,3 @@
+export default function matchEntity(jdlEntity) {
+    return jdlEntity?.name && jdlEntity.fields;
+}

package/dist/lib/jdl/core/matchers/field-matcher.js

@@ -0,0 +1,3 @@
+export default function matchField(jdlField) {
+    return jdlField?.name && jdlField.type && jdlField.validations && jdlField.options;
+}

package/dist/lib/jdl/core/models/jdl-application-configuration-factory.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 { JDLRuntime } from '../types/runtime.js';
+import JDLApplicationConfiguration from './jdl-application-configuration.js';
+export default function createApplicationConfigurationFromObject(configurationObject: {} | undefined, runtime: JDLRuntime): JDLApplicationConfiguration;
+export declare function createApplicationNamespaceConfigurationFromObject(parsedNamespaceConfigs: Record<string, Record<string, boolean | number | string[] | string>> | undefined, runtime: JDLRuntime): JDLApplicationConfiguration[];

package/dist/lib/jdl/core/models/jdl-application-configuration-factory.js

@@ -0,0 +1,94 @@
+/**
+ * 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 logger from '../utils/objects/logger.js';
+import JDLApplicationConfiguration from './jdl-application-configuration.js';
+import StringJDLApplicationConfigurationOption from './string-jdl-application-configuration-option.js';
+import IntegerJDLApplicationConfigurationOption from './integer-jdl-application-configuration-option.js';
+import BooleanJDLApplicationConfigurationOption from './boolean-jdl-application-configuration-option.js';
+import ListJDLApplicationConfigurationOption from './list-jdl-application-configuration-option.js';
+export default function createApplicationConfigurationFromObject(configurationObject = {}, runtime) {
+    const configuration = new JDLApplicationConfiguration();
+    Object.keys(configurationObject).forEach(optionName => {
+        const optionValue = configurationObject[optionName];
+        if (!runtime.applicationDefinition.doesOptionExist(optionName)) {
+            logger.debug(`Unrecognized application option name and value: '${optionName}' and '${optionValue}'.`);
+            return;
+        }
+        if ((Array.isArray(optionValue) || typeof optionValue === 'string') &&
+            !runtime.applicationDefinition.doesOptionValueExist(optionName, optionValue)) {
+            throw new Error(`The value '${optionValue}' is not allowed for the option '${optionName}'.`);
+        }
+        configuration.setOption(createApplicationJDLConfigurationOption(optionName, optionValue, runtime));
+    });
+    return configuration;
+}
+export function createApplicationNamespaceConfigurationFromObject(parsedNamespaceConfigs = {}, runtime) {
+    return Object.entries(parsedNamespaceConfigs).map(([namespace, parsedConfig]) => {
+        const configuration = new JDLApplicationConfiguration(namespace);
+        for (const [optionName, optionValue] of Object.entries(parsedConfig)) {
+            configuration.setOption(createUnknownJDLConfigurationOption(optionName, optionValue, runtime));
+        }
+        return configuration;
+    });
+}
+function createUnknownJDLConfigurationOption(name, value, runtime) {
+    let type;
+    if (typeof value === 'boolean') {
+        type = 'boolean';
+    }
+    else if (/^\d+$/.test(value)) {
+        value = parseInt(value, 10);
+        type = 'integer';
+    }
+    else if (Array.isArray(value)) {
+        type = 'list';
+    }
+    else if (typeof value === 'string') {
+        type = 'string';
+    }
+    else {
+        throw new Error(`Unknown value type for option ${name}`);
+    }
+    return createJDLConfigurationOption(type, name, value, runtime);
+}
+function createApplicationJDLConfigurationOption(name, value, runtime) {
+    const type = runtime.applicationDefinition.getTypeForOption(name);
+    return createJDLConfigurationOption(type, name, value, runtime);
+}
+function createJDLConfigurationOption(type, name, value, runtime) {
+    switch (type) {
+        case 'string':
+            return new StringJDLApplicationConfigurationOption(name, value, runtime.applicationDefinition.shouldTheValueBeQuoted(name));
+        case 'integer':
+            return new IntegerJDLApplicationConfigurationOption(name, value);
+        case 'boolean':
+            return new BooleanJDLApplicationConfigurationOption(name, value);
+        case 'list':
+            return new ListJDLApplicationConfigurationOption(name, value);
+        case 'quotedList':
+            return new ListJDLApplicationConfigurationOption(name, value, true);
+        /* istanbul ignore next */
+        default:
+            // It should not happen! This is a developer error.
+            // If this is the case then an option's type isn't one of the cases
+            // If there's a new option type, then you should handle it in the switch.
+            // If there's no new option type, then you may have made a mistake.
+            throw new Error(`Unrecognized option type: ${type}.`);
+    }
+}

package/dist/lib/jdl/core/models/jdl-application-configuration.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 JDLApplicationConfigurationOption from './jdl-application-configuration-option.js';
+export default class JDLApplicationConfiguration {
+    options: Record<string, JDLApplicationConfigurationOption<any>>;
+    namespace?: string;
+    constructor(namespace?: string);
+    hasOption(optionName: string): boolean;
+    getOption(optionName: string): JDLApplicationConfigurationOption<any> | undefined;
+    setOption(option: JDLApplicationConfigurationOption<any>): void;
+    forEachOption(passedFunction: (option: JDLApplicationConfigurationOption<any>) => void): void;
+    toString(indent?: number): string;
+}

package/dist/lib/jdl/core/models/jdl-application-configuration.js

@@ -0,0 +1,100 @@
+/**
+ * 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 { applicationOptions as ApplicationOptions } from '../built-in-options/index.js';
+const { OptionNames } = ApplicationOptions;
+export default class JDLApplicationConfiguration {
+    options;
+    namespace;
+    constructor(namespace) {
+        this.options = {};
+        this.namespace = namespace;
+    }
+    hasOption(optionName) {
+        if (!optionName) {
+            return false;
+        }
+        return optionName in this.options;
+    }
+    getOption(optionName) {
+        if (!optionName) {
+            throw new Error('An option name has to be passed to get the option.');
+        }
+        if (!(optionName in this.options)) {
+            return undefined;
+        }
+        return this.options[optionName];
+    }
+    setOption(option) {
+        if (!option) {
+            throw new Error('An option has to be passed to set an option.');
+        }
+        this.options[option.name] = option;
+    }
+    forEachOption(passedFunction) {
+        if (!passedFunction) {
+            return;
+        }
+        Object.values(this.options).forEach(option => {
+            passedFunction(option);
+        });
+    }
+    toString(indent = 0) {
+        const spaceBeforeConfigKeyword = ' '.repeat(indent);
+        const namespace = this.namespace ? `:${this.namespace}` : '';
+        if (Object.keys(this.options).length === 0) {
+            return `${spaceBeforeConfigKeyword}config${namespace} {}`;
+        }
+        const spaceBeforeOption = ' '.repeat(2 * indent);
+        const config = getFormattedConfigOptionsString(this.options, spaceBeforeOption);
+        return `${spaceBeforeConfigKeyword}config${namespace} {
+${config}
+${spaceBeforeConfigKeyword}}`;
+    }
+}
+function getFormattedConfigOptionsString(options, indent) {
+    const filteredOptions = filterOutUnwantedOptions(options);
+    return Object.keys(filteredOptions)
+        .sort()
+        .map(optionName => {
+        const option = options[optionName];
+        return `${indent}${option}`;
+    })
+        .join('\n');
+}
+function filterOutUnwantedOptions(options) {
+    return filterOutOptionsThatShouldNotBeExported(filterOutOptionsWithoutValues(options));
+}
+function filterOutOptionsWithoutValues(options) {
+    const filteredOptions = { ...options };
+    if (!(OptionNames.ENTITY_SUFFIX in options) || !options[OptionNames.ENTITY_SUFFIX].getValue()) {
+        delete filteredOptions[OptionNames.ENTITY_SUFFIX];
+    }
+    if (!(OptionNames.DTO_SUFFIX in options) || !options[OptionNames.DTO_SUFFIX].getValue()) {
+        delete filteredOptions[OptionNames.DTO_SUFFIX];
+    }
+    if (!(OptionNames.CLIENT_THEME_VARIANT in options) || !options[OptionNames.CLIENT_THEME_VARIANT].getValue()) {
+        delete filteredOptions[OptionNames.CLIENT_THEME_VARIANT];
+    }
+    return filteredOptions;
+}
+function filterOutOptionsThatShouldNotBeExported(options) {
+    const filteredOptions = { ...options };
+    delete filteredOptions[OptionNames.PACKAGE_FOLDER];
+    return filteredOptions;
+}

package/dist/lib/jdl/core/models/jdl-application-factory.d.ts

@@ -0,0 +1,9 @@
+import type { JDLRuntime } from '../types/runtime.js';
+import JDLApplication from './jdl-application.js';
+/**
+ * Creates a JDL application from a passed configuration.
+ * @param {Object} config - the application configuration.
+ * @returns {JDLApplication} the created JDL application.
+ */
+export declare function createJDLApplication(config: any, namespaceConfigs: Record<string, Record<string, any>> | undefined, runtime?: JDLRuntime): JDLApplication;
+export default createJDLApplication;

package/dist/lib/jdl/core/models/jdl-application-factory.js

@@ -0,0 +1,29 @@
+/**
+ * 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 { getDefaultRuntime } from '../runtime.js';
+import JDLApplication from './jdl-application.js';
+/**
+ * Creates a JDL application from a passed configuration.
+ * @param {Object} config - the application configuration.
+ * @returns {JDLApplication} the created JDL application.
+ */
+export function createJDLApplication(config, namespaceConfigs, runtime = getDefaultRuntime()) {
+    return new JDLApplication({ config: { baseName: 'jhipster', ...config }, namespaceConfigs }, runtime);
+}
+export default createJDLApplication;

package/dist/lib/jdl/core/models/jdl-application.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 { JDLRuntime } from '../types/runtime.js';
+import type JDLApplicationConfigurationOption from './jdl-application-configuration-option.js';
+import type JDLApplicationConfiguration from './jdl-application-configuration.js';
+import JDLApplicationEntities from './jdl-application-entities.js';
+import JDLOptions from './jdl-options.js';
+import type AbstractJDLOption from './abstract-jdl-option.js';
+export default class JDLApplication {
+    config: JDLApplicationConfiguration;
+    namespaceConfigs: JDLApplicationConfiguration[];
+    entityNames: JDLApplicationEntities;
+    options: JDLOptions;
+    constructor({ config, entityNames, namespaceConfigs }: any, runtime: JDLRuntime);
+    setConfigurationOption(option: JDLApplicationConfigurationOption<any>): void;
+    hasConfigurationOption(optionName: string): boolean;
+    getConfigurationOptionValue(optionName: string): any;
+    forEachConfigurationOption(passedFunction: (option: JDLApplicationConfigurationOption<any>) => void): void;
+    forEachNamespaceConfiguration(passedFunction: (option: JDLApplicationConfiguration) => void): void;
+    addEntityName(entityName: string): void;
+    addEntityNames(entityNames?: string[]): void;
+    getEntityNames(): string[];
+    hasEntityName(entityName: string): boolean;
+    forEachEntityName(passedFunction: any): void;
+    addOption(jdlOption: AbstractJDLOption | undefined): void;
+    forEachOption(passedFunction: (option: AbstractJDLOption) => void): void;
+    getOptionQuantity(): number;
+    toString(): string;
+}

package/dist/lib/jdl/core/models/jdl-application.js

@@ -0,0 +1,109 @@
+/**
+ * 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 createApplicationConfigurationFromObject, { createApplicationNamespaceConfigurationFromObject, } from './jdl-application-configuration-factory.js';
+import JDLApplicationEntities from './jdl-application-entities.js';
+import JDLOptions from './jdl-options.js';
+export default class JDLApplication {
+    config;
+    namespaceConfigs;
+    entityNames;
+    options;
+    constructor({ config = {}, entityNames = [], namespaceConfigs = {} } = {}, runtime) {
+        this.config = createApplicationConfigurationFromObject(config, runtime);
+        this.namespaceConfigs = createApplicationNamespaceConfigurationFromObject(namespaceConfigs, runtime);
+        this.entityNames = new JDLApplicationEntities(entityNames);
+        this.options = new JDLOptions();
+    }
+    setConfigurationOption(option) {
+        if (!option) {
+            throw new Error('An option has to be passed to set an option.');
+        }
+        this.config.setOption(option);
+    }
+    hasConfigurationOption(optionName) {
+        return this.config.hasOption(optionName);
+    }
+    getConfigurationOptionValue(optionName) {
+        if (!optionName) {
+            throw new Error('An option name has to be passed to get a value.');
+        }
+        if (!this.config.hasOption(optionName)) {
+            return undefined;
+        }
+        const option = this.config.getOption(optionName);
+        return option.getValue();
+    }
+    forEachConfigurationOption(passedFunction) {
+        this.config.forEachOption(passedFunction);
+    }
+    forEachNamespaceConfiguration(passedFunction) {
+        for (const namespaceConfig of this.namespaceConfigs) {
+            passedFunction(namespaceConfig);
+        }
+    }
+    addEntityName(entityName) {
+        if (!entityName) {
+            throw new Error('An entity name has to be passed so as to be added to the application.');
+        }
+        this.entityNames.add(entityName);
+    }
+    addEntityNames(entityNames = []) {
+        this.entityNames.addEntityNames(entityNames);
+    }
+    getEntityNames() {
+        return this.entityNames.toArray();
+    }
+    hasEntityName(entityName) {
+        if (!entityName) {
+            return false;
+        }
+        return this.entityNames.has(entityName);
+    }
+    forEachEntityName(passedFunction) {
+        this.entityNames.forEach(passedFunction);
+    }
+    addOption(jdlOption) {
+        if (!jdlOption) {
+            throw new Error("Can't add a nil option.");
+        }
+        this.options.addOption(jdlOption);
+    }
+    forEachOption(passedFunction) {
+        if (!passedFunction) {
+            return;
+        }
+        this.options.forEach(passedFunction);
+    }
+    getOptionQuantity() {
+        return this.options.size();
+    }
+    toString() {
+        let stringifiedApplication = `application {
+${this.config.toString(2)}
+${this.namespaceConfigs.map(config => `${config.toString(2)}\n`).join()}`;
+        if (this.entityNames.size() !== 0) {
+            stringifiedApplication += `\n${this.entityNames.toString(2)}\n`;
+        }
+        if (this.options.size() !== 0) {
+            stringifiedApplication += `\n${this.options.toString(2)}\n`;
+        }
+        stringifiedApplication += '}';
+        return stringifiedApplication;
+    }
+}

package/dist/lib/jdl/core/models/jdl-binary-option.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 type { JDLOptionParams } from './abstract-jdl-option.js';
+import AbstractJDLOption from './abstract-jdl-option.js';
+/**
+ * For options like the DTO, the service, etc.
+ */
+export default class JDLBinaryOption extends AbstractJDLOption {
+    value: string;
+    constructor(args: JDLOptionParams & {
+        value: string;
+    });
+    getType(): string;
+    toString(): string;
+}