generator-jhipster 8.7.0 → 8.7.2

package/dist/lib/jdl/jdl-importer.d.ts

@@ -0,0 +1,65 @@
+import type { JDLApplicationConfig } from './core/types/parsing.js';
+/**
+ * Creates a new JDL importer from files.
+ * There are two ways to create an importer:
+ *   - By providing an existing application content, if there's one
+ *   - Deprecated: providing some application options
+ *
+ * @param {Array} files - the JDL files to parse.
+ * @param {Object} configuration - a configuration object.
+ * @param {Object} configuration.application - an existing application file content
+ * @param {String} configuration.applicationName - deprecated, the application's name, optional if parsing applications
+ * @param {String} configuration.applicationType - deprecated, the application type, optional if parsing applications
+ * @param {String} configuration.databaseType - deprecated, the database type, optional if parsing applications
+ * @returns {Object} a JDL importer.
+ * @throws {Error} if files aren't passed.
+ */
+export declare function createImporterFromFiles(files: any, configuration?: any, definition?: JDLApplicationConfig): {
+    /**
+     * Processes JDL files and converts them to JSON.
+     * @param {Object} logger - the logger to use, default to the console.
+     * @returns {object} the state of the process:
+     *          - exportedDeployments: the exported deployments, or an empty list
+     *          - exportedApplications: the exported applications, or an empty list
+     *          - exportedEntities: the exported entities, or an empty list
+     */
+    import: (logger?: Console) => ImportState;
+};
+/**
+ * Creates a new JDL importer from a JDL string content.
+ * There are two ways to create an importer:
+ *   - By providing an existing application content, if there's one
+ *   - Deprecated: providing some application options
+ *
+ * @param {String} jdlString - the JDL String content to parse.
+ * @param {Object} configuration - a configuration object.
+ * @param {Object} configuration.application - an existing application file content
+ * @param {String} configuration.applicationName - deprecated, the application's name, optional if parsing applications
+ * @param {String} configuration.applicationType - deprecated, the application type, optional if parsing applications
+ * @param {String} configuration.databaseType - deprecated, the database type, optional if parsing applications
+ * @param {Array} configuration.blueprints - the blueprints used.
+ * @returns {Object} a JDL importer.
+ * @throws {Error} if the content isn't passed.
+ */
+export declare function createImporterFromContent(jdlString: any, configuration?: any, definition?: JDLApplicationConfig): {
+    /**
+     * Processes JDL files and converts them to JSON.
+     * @param {Object} logger - the logger to use, default to the console.
+     * @returns {object} the state of the process:
+     *          - exportedDeployments: the exported deployments, or an empty list
+     *          - exportedApplications: the exported applications, or an empty list
+     *          - exportedEntities: the exported entities, or an empty list
+     */
+    import: (logger?: Console) => ImportState;
+};
+export type ApplicationWithEntities = {
+    config: any;
+    namespaceConfigs: Record<string, Record<string, any>>;
+    entities: any[];
+};
+export type ImportState = {
+    exportedApplications: any[];
+    exportedApplicationsWithEntities: Record<string, ApplicationWithEntities>;
+    exportedEntities: any[];
+    exportedDeployments: any[];
+};

package/dist/lib/jdl/jdl-importer.js

@@ -0,0 +1,272 @@
+/**
+ * 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 { uniqBy } from 'lodash-es';
+import { applicationOptions } from '../jhipster/index.js';
+import { readCurrentPathYoRcFile } from '../utils/yo-rc.js';
+import ParsedJDLToJDLObjectConverter from './converters/parsed-jdl-to-jdl-object/parsed-jdl-to-jdl-object-converter.js';
+import JDLWithoutApplicationToJSONConverter from './converters/jdl-to-json/jdl-without-application-to-json-converter.js';
+import { convert } from './converters/jdl-to-json/jdl-with-applications-to-json-converter.js';
+import { formatApplicationToExport, formatApplicationsToExport, } from './converters/exporters/applications/jhipster-application-formatter.js';
+import exportDeployments from './converters/exporters/jhipster-deployment-exporter.js';
+import exportEntities from './converters/exporters/jhipster-entity-exporter.js';
+import { GENERATOR_NAME } from './converters/exporters/export-utils.js';
+import { parseFromContent, parseFromFiles } from './core/readers/jdl-reader.js';
+import createWithApplicationValidator from './converters/validators/jdl-with-application-validator.js';
+import createWithoutApplicationValidator from './converters/validators/jdl-without-application-validator.js';
+import { createRuntime, getDefaultRuntime } from './core/runtime.js';
+const { OptionNames } = applicationOptions;
+const { APPLICATION_TYPE, BASE_NAME } = OptionNames;
+const GENERATOR_JHIPSTER = 'generator-jhipster'; // can't use the one of the generator as it circles
+/**
+ * Creates a new JDL importer from files.
+ * There are two ways to create an importer:
+ *   - By providing an existing application content, if there's one
+ *   - Deprecated: providing some application options
+ *
+ * @param {Array} files - the JDL files to parse.
+ * @param {Object} configuration - a configuration object.
+ * @param {Object} configuration.application - an existing application file content
+ * @param {String} configuration.applicationName - deprecated, the application's name, optional if parsing applications
+ * @param {String} configuration.applicationType - deprecated, the application type, optional if parsing applications
+ * @param {String} configuration.databaseType - deprecated, the database type, optional if parsing applications
+ * @returns {Object} a JDL importer.
+ * @throws {Error} if files aren't passed.
+ */
+export function createImporterFromFiles(files, configuration, definition) {
+    if (!files) {
+        throw new Error('Files must be passed to create a new JDL importer.');
+    }
+    const runtime = definition ? createRuntime(definition) : getDefaultRuntime();
+    const content = parseFromFiles(files, runtime);
+    return makeJDLImporter(content, configuration || {}, runtime);
+}
+/**
+ * Creates a new JDL importer from a JDL string content.
+ * There are two ways to create an importer:
+ *   - By providing an existing application content, if there's one
+ *   - Deprecated: providing some application options
+ *
+ * @param {String} jdlString - the JDL String content to parse.
+ * @param {Object} configuration - a configuration object.
+ * @param {Object} configuration.application - an existing application file content
+ * @param {String} configuration.applicationName - deprecated, the application's name, optional if parsing applications
+ * @param {String} configuration.applicationType - deprecated, the application type, optional if parsing applications
+ * @param {String} configuration.databaseType - deprecated, the database type, optional if parsing applications
+ * @param {Array} configuration.blueprints - the blueprints used.
+ * @returns {Object} a JDL importer.
+ * @throws {Error} if the content isn't passed.
+ */
+export function createImporterFromContent(jdlString, configuration, definition) {
+    if (!jdlString) {
+        throw new Error('A JDL content must be passed to create a new JDL importer.');
+    }
+    const runtime = definition ? createRuntime(definition) : getDefaultRuntime();
+    const content = parseFromContent(jdlString, runtime);
+    return makeJDLImporter(content, configuration || {}, runtime);
+}
+function makeJDLImporter(content, configuration, runtime) {
+    let importState = {
+        exportedApplications: [],
+        exportedApplicationsWithEntities: {},
+        exportedEntities: [],
+        exportedDeployments: [],
+    };
+    return {
+        /**
+         * Processes JDL files and converts them to JSON.
+         * @param {Object} logger - the logger to use, default to the console.
+         * @returns {object} the state of the process:
+         *          - exportedDeployments: the exported deployments, or an empty list
+         *          - exportedApplications: the exported applications, or an empty list
+         *          - exportedEntities: the exported entities, or an empty list
+         */
+        import: (logger = console) => {
+            const jdlObject = getJDLObject(content, configuration, runtime);
+            checkForErrors(jdlObject, configuration, logger);
+            if (jdlObject.getApplicationQuantity() === 0 && jdlObject.getEntityQuantity() > 0) {
+                importState.exportedEntities = importOnlyEntities(jdlObject, configuration);
+            }
+            else if (jdlObject.getApplicationQuantity() === 1) {
+                importState = importOneApplicationAndEntities(jdlObject);
+            }
+            else {
+                importState = importApplicationsAndEntities(jdlObject);
+            }
+            if (jdlObject.getDeploymentQuantity()) {
+                importState.exportedDeployments = importDeployments(jdlObject.deployments);
+            }
+            return importState;
+        },
+    };
+}
+function getJDLObject(parsedJDLContent, configuration, runtime) {
+    let baseName = configuration.applicationName;
+    let applicationType = configuration.applicationType;
+    let databaseType = configuration.databaseType;
+    if (configuration.application) {
+        baseName = configuration.application[GENERATOR_JHIPSTER].baseName;
+        applicationType = configuration.application[GENERATOR_JHIPSTER].applicationType;
+        databaseType = configuration.application[GENERATOR_JHIPSTER].databaseType;
+    }
+    return ParsedJDLToJDLObjectConverter.parseFromConfigurationObject({
+        parsedContent: parsedJDLContent,
+        applicationType,
+        applicationName: baseName,
+        databaseType,
+    }, runtime);
+}
+function checkForErrors(jdlObject, configuration, logger = console) {
+    let validator;
+    if (jdlObject.getApplicationQuantity() === 0) {
+        let application = configuration.application;
+        if (!application) {
+            application = readCurrentPathYoRcFile();
+        }
+        let applicationType = configuration.applicationType;
+        let databaseType = configuration.databaseType;
+        let blueprints = configuration.blueprints;
+        if (application?.[GENERATOR_JHIPSTER]) {
+            if (applicationType === undefined) {
+                applicationType = application[GENERATOR_JHIPSTER].applicationType;
+            }
+            if (databaseType === undefined) {
+                databaseType = application[GENERATOR_JHIPSTER].databaseType;
+            }
+            if (blueprints === undefined) {
+                blueprints = application[GENERATOR_JHIPSTER].blueprints;
+            }
+        }
+        validator = createWithoutApplicationValidator(jdlObject, {
+            applicationType,
+            databaseType,
+            blueprints,
+        }, logger);
+    }
+    else {
+        validator = createWithApplicationValidator(jdlObject, logger);
+    }
+    validator.checkForErrors();
+}
+function importOnlyEntities(jdlObject, configuration) {
+    let { applicationName, applicationType, databaseType } = configuration;
+    let application = configuration.application;
+    if (!application) {
+        application = readCurrentPathYoRcFile();
+    }
+    if (application?.[GENERATOR_JHIPSTER]) {
+        if (applicationType === undefined) {
+            applicationType = application[GENERATOR_JHIPSTER].applicationType;
+        }
+        if (applicationName === undefined) {
+            applicationName = application[GENERATOR_JHIPSTER].baseName;
+        }
+        if (databaseType === undefined) {
+            databaseType = application[GENERATOR_JHIPSTER].databaseType;
+        }
+    }
+    const entitiesPerApplicationMap = JDLWithoutApplicationToJSONConverter.convert({
+        jdlObject,
+        applicationName,
+        applicationType,
+        databaseType,
+    });
+    const jsonEntities = entitiesPerApplicationMap.get(applicationName);
+    return exportJSONEntities(jsonEntities, configuration);
+}
+function importOneApplicationAndEntities(jdlObject) {
+    const importState = {
+        exportedApplications: [],
+        exportedApplicationsWithEntities: {},
+        exportedEntities: [],
+        exportedDeployments: [],
+    };
+    const formattedApplication = formatApplicationToExport(jdlObject.getApplications()[0]);
+    importState.exportedApplications.push(formattedApplication);
+    const jdlApplication = jdlObject.getApplications()[0];
+    const applicationName = jdlApplication.getConfigurationOptionValue(BASE_NAME);
+    const entitiesPerApplicationMap = convert({
+        jdlObject,
+    });
+    const jsonEntities = entitiesPerApplicationMap.get(applicationName);
+    const { [GENERATOR_NAME]: config, ...remaining } = formattedApplication;
+    importState.exportedApplicationsWithEntities[applicationName] = {
+        config,
+        ...remaining,
+        entities: [],
+    };
+    if (jsonEntities.length !== 0) {
+        const exportedJSONEntities = exportJSONEntities(jsonEntities, {
+            applicationName,
+            applicationType: jdlApplication.getConfigurationOptionValue(APPLICATION_TYPE),
+            forSeveralApplications: false,
+        });
+        importState.exportedApplicationsWithEntities[applicationName].entities = exportedJSONEntities;
+        importState.exportedEntities = uniqBy([...importState.exportedEntities, ...exportedJSONEntities], 'name');
+    }
+    return importState;
+}
+function importApplicationsAndEntities(jdlObject) {
+    const importState = {
+        exportedApplications: [],
+        exportedApplicationsWithEntities: {},
+        exportedEntities: [],
+        exportedDeployments: [],
+    };
+    const formattedApplications = formatApplicationsToExport(jdlObject.applications);
+    importState.exportedApplications = formattedApplications;
+    const entitiesPerApplicationMap = convert({
+        jdlObject,
+    });
+    entitiesPerApplicationMap.forEach((jsonEntities, applicationName) => {
+        const jdlApplication = jdlObject.getApplication(applicationName);
+        const exportedJSONEntities = exportJSONEntities(jsonEntities, {
+            applicationName,
+            applicationType: jdlApplication.getConfigurationOptionValue(APPLICATION_TYPE),
+            forSeveralApplications: true,
+        });
+        const exportedConfig = importState.exportedApplications.find(config => applicationName === config['generator-jhipster'].baseName);
+        const { 'generator-jhipster': config, ...remaining } = exportedConfig;
+        importState.exportedApplicationsWithEntities[applicationName] = {
+            config,
+            ...remaining,
+            entities: exportedJSONEntities,
+        };
+        importState.exportedEntities = uniqBy([...importState.exportedEntities, ...exportedJSONEntities], 'name');
+    });
+    return importState;
+}
+function importDeployments(deployments) {
+    return exportDeployments(deployments);
+}
+function exportJSONEntities(entities, configuration) {
+    let baseName = configuration.applicationName;
+    let applicationType = configuration.applicationType;
+    if (configuration.application) {
+        baseName = configuration.application[GENERATOR_JHIPSTER].baseName;
+        applicationType = configuration.application[GENERATOR_JHIPSTER].applicationType;
+    }
+    return exportEntities({
+        entities,
+        application: {
+            name: baseName,
+            type: applicationType,
+            forSeveralApplications: !!configuration.forSeveralApplications,
+        },
+    });
+}

package/dist/lib/jhipster/application-options.d.ts

@@ -0,0 +1,80 @@
+/**
+ * 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 { JDLApplicationConfig, JDLApplicationOptionType, JDLApplicationOptionValue } from '../jdl/core/types/parsing.js';
+export declare const jhipsterOptionValues: Record<string, JDLApplicationOptionValue>;
+export declare const jhipsterOptionTypes: Record<string, JDLApplicationOptionType>;
+export declare const jhipsterQuotedOptionNames: string[];
+export declare const builtInJDLApplicationConfig: JDLApplicationConfig;
+declare const _default: {
+    OptionNames: {
+        APPLICATION_TYPE: string;
+        AUTHENTICATION_TYPE: string;
+        BASE_NAME: string;
+        BLUEPRINT: string;
+        BLUEPRINTS: string;
+        BUILD_TOOL: string;
+        CACHE_PROVIDER: string;
+        CLIENT_FRAMEWORK: string;
+        CLIENT_PACKAGE_MANAGER: string;
+        CLIENT_THEME: string;
+        CLIENT_THEME_VARIANT: string;
+        WITH_ADMIN_UI: string;
+        CREATION_TIMESTAMP: string;
+        DATABASE_TYPE: string;
+        DEV_DATABASE_TYPE: string;
+        DTO_SUFFIX: string;
+        EMBEDDABLE_LAUNCH_SCRIPT: string;
+        ENABLE_HIBERNATE_CACHE: string;
+        ENABLE_SWAGGER_CODEGEN: string;
+        ENABLE_TRANSLATION: string;
+        ENTITY_SUFFIX: string;
+        EXPERIMENTAL: string;
+        GATEWAY_SERVER_PORT: string;
+        I_18_N: string;
+        INSTALL_MODULES: string;
+        JHI_PREFIX: string;
+        JHIPSTER_VERSION: string;
+        JWT_SECRET_KEY: string;
+        LANGUAGES: string;
+        MICROFRONTEND: string;
+        MICROFRONTENDS: string;
+        NATIVE_LANGUAGE: string;
+        NPM: string;
+        PACKAGE_NAME: string;
+        PACKAGE_FOLDER: string;
+        PROD_DATABASE_TYPE: string;
+        REACTIVE: string;
+        REMEMBER_ME_KEY: string;
+        SEARCH_ENGINE: string;
+        SERVER_PORT: string;
+        SERVICE_DISCOVERY_TYPE: string;
+        SKIP_CLIENT: string;
+        SKIP_GIT: string;
+        SKIP_INSTALL: string;
+        SKIP_SERVER: string;
+        SKIP_USER_MANAGEMENT: string;
+        TEST_FRAMEWORKS: string;
+        WEBSOCKET: string;
+        ENABLE_GRADLE_ENTERPRISE: string;
+        GRADLE_ENTERPRISE_HOST: string;
+    };
+    OptionValues: Record<string, JDLApplicationOptionValue>;
+    QuotedOptionNames: string[];
+};
+export default _default;