generator-jhipster 8.7.0 → 8.7.1

package/dist/jdl/models/jdl-object.js

@@ -1,252 +0,0 @@
-/**
- * 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 '../jhipster/index.js';
-import JDLEnums from './jdl-enums.js';
-import JDLRelationships from './jdl-relationships.js';
-import JDLOptions from './jdl-options.js';
-/**
- * The JDL object class, containing applications, entities etc.
- */
-export default class JDLObject {
-    applications;
-    deployments;
-    entities;
-    enums;
-    relationships;
-    options;
-    constructor() {
-        this.applications = {};
-        this.deployments = {};
-        this.entities = {};
-        this.enums = new JDLEnums();
-        this.relationships = new JDLRelationships();
-        this.options = new JDLOptions();
-    }
-    getOptions() {
-        return this.options.getOptions();
-    }
-    /**
-     * Adds or replaces an application.
-     * @param application the application.
-     */
-    addApplication(application) {
-        if (!application) {
-            throw new Error("Can't add nil application.");
-        }
-        const baseName = application.getConfigurationOptionValue('baseName');
-        this.applications[baseName] = application;
-    }
-    getApplicationQuantity() {
-        return Object.keys(this.applications).length;
-    }
-    getApplication(applicationName) {
-        if (!applicationName) {
-            return undefined;
-        }
-        return this.applications[applicationName];
-    }
-    getApplications() {
-        return Object.values(this.applications);
-    }
-    forEachApplication(passedFunction) {
-        if (!passedFunction) {
-            return;
-        }
-        Object.keys(this.applications).forEach(applicationName => {
-            const application = this.applications[applicationName];
-            passedFunction(application);
-        });
-    }
-    /**
-     * Adds or replaces a deployment.
-     * @param deployment the deployment.
-     */
-    addDeployment(deployment) {
-        if (!deployment) {
-            throw new Error("Can't add nil deployment.");
-        }
-        this.deployments[deployment.deploymentType] = deployment;
-    }
-    getDeploymentQuantity() {
-        return Object.keys(this.deployments).length;
-    }
-    forEachDeployment(passedFunction) {
-        if (!passedFunction) {
-            return;
-        }
-        Object.keys(this.deployments).forEach((deploymentName, index, array) => {
-            const deployment = this.deployments[deploymentName];
-            passedFunction(deployment, index, array);
-        });
-    }
-    /**
-     * Adds or replaces an entity.
-     * @param entity the entity to add.
-     */
-    addEntity(entity) {
-        if (!entity) {
-            throw new Error("Can't add nil entity.");
-        }
-        this.entities[entity.name] = entity;
-    }
-    getEntity(entityName) {
-        if (!entityName) {
-            throw new Error('An entity name must be passed so as to be retrieved.');
-        }
-        return this.entities[entityName];
-    }
-    getEntities() {
-        return Object.values(this.entities);
-    }
-    getEntityQuantity() {
-        return this.getEntityNames().length;
-    }
-    getEntityNames() {
-        return Object.keys(this.entities);
-    }
-    forEachEntity(passedFunction) {
-        if (!passedFunction) {
-            return;
-        }
-        Object.keys(this.entities).forEach((entityName, index, array) => {
-            const entity = this.entities[entityName];
-            passedFunction(entity, index, array);
-        });
-    }
-    /**
-     * Adds or replaces an enum.
-     * @param enumToAdd the enum to add.
-     */
-    addEnum(enumToAdd) {
-        if (!enumToAdd) {
-            throw new Error("Can't add nil enum.");
-        }
-        this.enums.add(enumToAdd);
-    }
-    hasEnum(enumName) {
-        return this.enums.has(enumName);
-    }
-    getEnum(enumName) {
-        return this.enums.get(enumName);
-    }
-    getEnumQuantity() {
-        return this.enums.size();
-    }
-    forEachEnum(passedFunction) {
-        if (!passedFunction) {
-            return;
-        }
-        this.enums.forEach(jdlEnum => {
-            passedFunction(jdlEnum);
-        });
-    }
-    addRelationship(relationship) {
-        if (!relationship) {
-            throw new Error("Can't add nil relationship.");
-        }
-        this.relationships.add(relationship);
-    }
-    getRelationshipQuantity(applicationName) {
-        if (!applicationName) {
-            return this.relationships.size();
-        }
-        const applicationEntityNames = this.applications[applicationName].entityNames;
-        let count = 0;
-        this.relationships.forEach(relationship => {
-            if (applicationEntityNames.has(relationship.from) || applicationEntityNames.has(relationship.to)) {
-                count++;
-            }
-        });
-        return count;
-    }
-    forEachRelationship(passedFunction) {
-        if (!passedFunction) {
-            return;
-        }
-        this.relationships.forEach(jdlRelationship => {
-            passedFunction(jdlRelationship);
-        });
-    }
-    getRelationships() {
-        return this.relationships.toArray();
-    }
-    addOption(option) {
-        if (!option || !option.getType) {
-            throw new Error("Can't add nil option.");
-        }
-        this.options.addOption(option);
-    }
-    getOptionsForName(optionName) {
-        return this.options.getOptionsForName(optionName);
-    }
-    forEachOption(passedFunction) {
-        if (!passedFunction) {
-            return;
-        }
-        this.options.forEach(passedFunction);
-    }
-    hasOption(optionName) {
-        if (!optionName) {
-            return false;
-        }
-        return this.options.has(optionName);
-    }
-    isEntityInMicroservice(entityName) {
-        const options = this.getOptionsForName(binaryOptions.Options.MICROSERVICE);
-        return options.some(option => option.entityNames.has('*') || option.entityNames.has(entityName));
-    }
-    getOptionQuantity() {
-        return this.options.size();
-    }
-    toString() {
-        return [
-            applicationsToString(this.applications),
-            deploymentsToString(this.deployments),
-            entitiesToString(this.entities),
-            this.enums.toString(),
-            relationshipsToString(this.relationships),
-            optionsToString(this.options),
-        ]
-            .map(section => section.trim())
-            .filter(Boolean)
-            .join('\n\n')
-            .concat('\n');
-    }
-}
-function applicationsToString(applications) {
-    return Object.values(applications)
-        .map(application => application.toString())
-        .join('\n');
-}
-function deploymentsToString(deployments) {
-    return Object.values(deployments)
-        .map(deployment => deployment.toString())
-        .join('\n');
-}
-function entitiesToString(entities) {
-    return Object.values(entities)
-        .map(entity => entity.toString())
-        .join('\n');
-}
-function relationshipsToString(relationships) {
-    return relationships.toString();
-}
-function optionsToString(options) {
-    return options.toString();
-}

package/dist/jdl/models/jdl-options.js

@@ -1,84 +0,0 @@
-export default class JDLOptions {
-    options;
-    optionSize;
-    constructor() {
-        this.options = {};
-        this.optionSize = 0;
-    }
-    addOption(option) {
-        if (!option || !option.getType) {
-            throw new Error("Can't add nil option.");
-        }
-        if (option.getType() === 'UNARY') {
-            addUnaryOption(this.options, option);
-        }
-        else {
-            addBinaryOption(this.options, option);
-        }
-        this.optionSize++;
-    }
-    getOptions() {
-        const options = [];
-        Object.values(this.options).forEach(item => {
-            if (item.getType && item.getType() === 'UNARY') {
-                options.push(item);
-                return;
-            }
-            Object.values(item).forEach(option => options.push(option));
-        });
-        return options;
-    }
-    getOptionsForName(optionName) {
-        if (!optionName) {
-            return [];
-        }
-        return this.getOptions().filter(option => option.name === optionName);
-    }
-    has(optionName) {
-        if (!optionName) {
-            return false;
-        }
-        return !!this.options[optionName] || this.getOptions().filter(option => option.name === optionName).length !== 0;
-    }
-    size() {
-        return this.optionSize;
-    }
-    forEach(passedFunction, thisArg) {
-        if (!passedFunction) {
-            return;
-        }
-        this.getOptions().forEach(jdlOption => {
-            passedFunction.call(thisArg, jdlOption);
-        });
-    }
-    toString(indent = 0) {
-        if (this.optionSize === 0) {
-            return '';
-        }
-        const options = this.getOptions();
-        const spaceBeforeEachOption = ' '.repeat(indent);
-        return options.map(jdlOption => `${spaceBeforeEachOption}${jdlOption.toString()}`).join('\n');
-    }
-}
-function addUnaryOption(options, optionToAdd) {
-    const key = optionToAdd.name;
-    if (!options[key]) {
-        options[key] = optionToAdd;
-        return;
-    }
-    options[key].addEntitiesFromAnotherOption(optionToAdd);
-}
-function addBinaryOption(options, optionToAdd) {
-    const { name, value } = optionToAdd;
-    if (!options[name]) {
-        options[name] = {
-            [value]: optionToAdd,
-        };
-    }
-    else if (!options[name][value]) {
-        options[name][value] = optionToAdd;
-    }
-    else {
-        options[name][value].addEntitiesFromAnotherOption(optionToAdd);
-    }
-}

package/dist/jdl/models/jdl-relationship.js

@@ -1,162 +0,0 @@
-/**
- * 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 { upperFirst } from 'lodash-es';
-import { Validations } from '../jhipster/index.js';
-import { relationshipTypeExists } from '../jhipster/relationship-types.js';
-const { REQUIRED } = Validations;
-export default class JDLRelationship {
-    side;
-    from;
-    to;
-    type;
-    options;
-    injectedFieldInFrom;
-    injectedFieldInTo;
-    isInjectedFieldInFromRequired;
-    isInjectedFieldInToRequired;
-    commentInFrom;
-    commentInTo;
-    constructor(args) {
-        const merged = mergeDefaultsWithOverrides(args);
-        if (!merged.from || !merged.to) {
-            throw new Error('Source and destination entities must be passed to create a relationship.');
-        }
-        if (!relationshipTypeExists(merged.type) || !(merged.injectedFieldInFrom || merged.injectedFieldInTo)) {
-            throw new Error('A valid type and at least one injected field must be passed to create a relationship.');
-        }
-        this.side = merged.side;
-        this.from = merged.from;
-        this.to = merged.to;
-        this.type = merged.type;
-        this.options = merged.options;
-        this.injectedFieldInFrom = merged.injectedFieldInFrom;
-        this.injectedFieldInTo = merged.injectedFieldInTo;
-        this.isInjectedFieldInFromRequired = merged.isInjectedFieldInFromRequired;
-        this.isInjectedFieldInToRequired = merged.isInjectedFieldInToRequired;
-        this.commentInFrom = merged.commentInFrom;
-        this.commentInTo = merged.commentInTo;
-    }
-    /**
-     * Returns a constructed ID representing this relationship.
-     * @return {String} the relationship's id.
-     */
-    getId() {
-        return (`${this.type}_${this.from}${this.injectedFieldInFrom ? `{${this.injectedFieldInFrom}}` : ''}` +
-            `_${this.to}${this.injectedFieldInTo ? `{${this.injectedFieldInTo}}` : ''}`);
-    }
-    hasGlobalOption(option) {
-        return option in this.options.global;
-    }
-    forEachGlobalOption(passedFunction) {
-        Object.entries(this.options.global).forEach(([key, value]) => {
-            passedFunction(key, value);
-        });
-    }
-    forEachSourceOption(passedFunction) {
-        Object.entries(this.options.source).forEach(([key, value]) => {
-            passedFunction(key, value);
-        });
-    }
-    forEachDestinationOption(passedFunction) {
-        Object.entries(this.options.destination).forEach(([key, value]) => {
-            passedFunction(key, value);
-        });
-    }
-    // TODO: refactor this function
-    toString() {
-        let string = `relationship ${this.type} {\n  `;
-        if (this.commentInFrom) {
-            string += `/**\n${this.commentInFrom
-                .split('\n')
-                .map(line => `   * ${line}\n`)
-                .join('')}   */\n  `;
-        }
-        const sourceOptions = this.options.source;
-        if (Object.keys(sourceOptions).length !== 0) {
-            Object.keys(sourceOptions).forEach(name => {
-                const value = sourceOptions[name];
-                name = upperFirst(name);
-                string += `@${name}${value != null && value !== true ? `(${value}) ` : ' '}`;
-            });
-        }
-        string += `${this.from}`;
-        if (this.injectedFieldInFrom) {
-            string += `{${this.injectedFieldInFrom}${this.isInjectedFieldInFromRequired ? ` ${REQUIRED}` : ''}}`;
-        }
-        string += ' to';
-        if (this.commentInTo) {
-            string += `\n  /**\n${this.commentInTo
-                .split('\n')
-                .map(line => `   * ${line}\n`)
-                .join('')}   */\n  `;
-        }
-        else {
-            string += ' ';
-        }
-        const destinationOptions = this.options.destination;
-        if (Object.keys(destinationOptions).length !== 0) {
-            Object.keys(destinationOptions).forEach(name => {
-                const value = destinationOptions[name];
-                name = upperFirst(name);
-                string += `@${name}${value != null && value !== true ? `(${value}) ` : ' '}`;
-            });
-        }
-        string += `${this.to}`;
-        if (this.injectedFieldInTo) {
-            string += `{${this.injectedFieldInTo}${this.isInjectedFieldInToRequired ? ` ${REQUIRED}` : ''}}`;
-        }
-        const globalOptions = this.options.global;
-        if (Object.keys(globalOptions).length !== 0) {
-            string += ' with ';
-            Object.keys(globalOptions).forEach(name => {
-                string += `${name}, `;
-            });
-            string = string.substring(0, string.length - 2);
-        }
-        string += '\n}';
-        return string.replace(/ \n/g, '\n').replace(/[ ]{4}/g, '  ');
-    }
-}
-function mergeDefaultsWithOverrides(overrides) {
-    const defaultOptions = defaults();
-    const mergedOptions = {
-        ...defaultOptions,
-        ...overrides,
-    };
-    mergedOptions.options.global = mergedOptions.options.global || {};
-    mergedOptions.options.source = mergedOptions.options.source || {};
-    mergedOptions.options.destination = mergedOptions.options.destination || {};
-    return mergedOptions;
-}
-function defaults() {
-    return {
-        side: undefined,
-        injectedFieldInFrom: null,
-        injectedFieldInTo: null,
-        isInjectedFieldInFromRequired: false,
-        isInjectedFieldInToRequired: false,
-        options: {
-            global: {},
-            destination: {},
-            source: {},
-        },
-        commentInFrom: '',
-        commentInTo: '',
-    };
-}

package/dist/jdl/models/jdl-relationships.js

@@ -1,105 +0,0 @@
-/**
- * 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 '../jhipster/index.js';
-import { relationshipTypeExists } from '../jhipster/relationship-types.js';
-export default class JDLRelationships {
-    relationships;
-    constructor() {
-        this.relationships = {
-            OneToOne: new Map(),
-            OneToMany: new Map(),
-            ManyToOne: new Map(),
-            ManyToMany: new Map(),
-        };
-    }
-    add(relationship) {
-        if (!relationship) {
-            throw new Error('A relationship must be passed so as to be added.');
-        }
-        this.relationships[relationship.type].set(relationship.getId(), relationship);
-    }
-    getOneToOne(relationshipId) {
-        return this.get(relationshipTypes.ONE_TO_ONE, relationshipId);
-    }
-    getOneToMany(relationshipId) {
-        return this.get(relationshipTypes.ONE_TO_MANY, relationshipId);
-    }
-    getManyToOne(relationshipId) {
-        return this.get(relationshipTypes.MANY_TO_ONE, relationshipId);
-    }
-    getManyToMany(relationshipId) {
-        return this.get(relationshipTypes.MANY_TO_MANY, relationshipId);
-    }
-    get(type, relationshipId) {
-        if (!relationshipTypeExists(type)) {
-            throw new Error(`A valid relationship type must be passed so as to retrieve the relationship, got '${type}'.`);
-        }
-        if (!relationshipId) {
-            throw new Error('A relationship id must be passed so as to retrieve the relationship.');
-        }
-        return this.relationships[type].get(relationshipId);
-    }
-    oneToOneQuantity() {
-        return this.relationships.OneToOne.size;
-    }
-    oneToManyQuantity() {
-        return this.relationships.OneToMany.size;
-    }
-    manyToOneQuantity() {
-        return this.relationships.ManyToOne.size;
-    }
-    manyToManyQuantity() {
-        return this.relationships.ManyToMany.size;
-    }
-    size() {
-        return this.oneToOneQuantity() + this.oneToManyQuantity() + this.manyToOneQuantity() + this.manyToManyQuantity();
-    }
-    forEach(passedFunction) {
-        if (!passedFunction) {
-            return;
-        }
-        this.toArray().forEach(jdlRelationship => {
-            passedFunction(jdlRelationship);
-        });
-    }
-    toArray() {
-        const relationships = [];
-        Object.keys(this.relationships).forEach(type => {
-            this.relationships[type].forEach(relationship => {
-                relationships.push(relationship);
-            });
-        });
-        return relationships;
-    }
-    toString() {
-        if (this.size() === 0) {
-            return '';
-        }
-        return Object.entries(this.relationships)
-            .map(([key, relationships]) => (relationships.size > 0 ? relationshipTypeToString(relationships, key) : undefined))
-            .filter(Boolean)
-            .join('\n');
-    }
-}
-function relationshipTypeToString(relationships, type) {
-    const relationshipsLines = [...relationships.values()].map(relationship => relationship.toString().split('\n').slice(1, -1)).flat();
-    return `relationship ${type} {
-${relationshipsLines.join('\n')}
-}`;
-}

package/dist/jdl/models/jdl-validation.js

@@ -1,55 +0,0 @@
-/**
- * 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 { validations } from '../jhipster/index.js';
-const { Validations: { REQUIRED, PATTERN }, } = validations;
-export default class JDLValidation {
-    name;
-    value;
-    constructor(args) {
-        const merged = merge(defaults(), args);
-        this.name = merged.name;
-        this.value = merged.value;
-    }
-    toString() {
-        let string = `${this.name}`;
-        if (this.value || this.value === 0) {
-            string += `(${formatValidationValue(this.name, this.value)})`;
-        }
-        return string;
-    }
-}
-function defaults() {
-    return {
-        name: REQUIRED,
-        value: '',
-    };
-}
-function formatValidationValue(name, value) {
-    if (name === PATTERN) {
-        return getPatternValidationValue(value);
-    }
-    return value;
-}
-function getPatternValidationValue(value) {
-    if (value instanceof RegExp) {
-        return value.toString();
-    }
-    return `/${value}/`;
-}